@bananapus/core-v6 0.0.1

package/test/units/static/JBMetadataResolver/TestMetadataResolverFuzz.sol

@@ -0,0 +1,227 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBMetadataResolver} from "../../../../src/libraries/JBMetadataResolver.sol";
+
+/// @notice Wrapper contract to expose JBMetadataResolver internal functions for testing.
+contract MetadataResolverHarness {
+    function createMetadata(bytes4[] memory ids, bytes[] memory datas) external pure returns (bytes memory) {
+        return JBMetadataResolver.createMetadata(ids, datas);
+    }
+
+    function getDataFor(bytes4 id, bytes memory metadata) external pure returns (bool found, bytes memory targetData) {
+        return JBMetadataResolver.getDataFor(id, metadata);
+    }
+
+    function addToMetadata(
+        bytes memory originalMetadata,
+        bytes4 idToAdd,
+        bytes memory dataToAdd
+    )
+        external
+        pure
+        returns (bytes memory)
+    {
+        return JBMetadataResolver.addToMetadata(originalMetadata, idToAdd, dataToAdd);
+    }
+
+    function getId(string memory purpose, address target) external pure returns (bytes4) {
+        return JBMetadataResolver.getId(purpose, target);
+    }
+}
+
+/// @notice Fuzz tests for JBMetadataResolver library.
+contract TestMetadataResolverFuzz_Local is JBTest {
+    MetadataResolverHarness harness;
+
+    function setUp() external {
+        harness = new MetadataResolverHarness();
+    }
+
+    //*********************************************************************//
+    // --- Single Entry Round-Trip -------------------------------------- //
+    //*********************************************************************//
+
+    /// @notice createMetadata with 1 entry, then getDataFor retrieves it.
+    function testFuzz_singleEntry_roundTrip(bytes4 id, uint256 value) external view {
+        vm.assume(id != bytes4(0)); // 0 ID would be confused with padding
+
+        bytes4[] memory ids = new bytes4[](1);
+        ids[0] = id;
+
+        bytes[] memory datas = new bytes[](1);
+        datas[0] = abi.encodePacked(bytes32(value)); // Padded to 32 bytes
+
+        bytes memory metadata = harness.createMetadata(ids, datas);
+
+        (bool found, bytes memory result) = harness.getDataFor(id, metadata);
+        assertTrue(found, "ID should be found");
+        assertEq(abi.decode(result, (uint256)), value, "data should match");
+    }
+
+    /// @notice Missing ID returns (false, "").
+    function testFuzz_missingId_returnsEmpty(bytes4 id, bytes4 searchId, uint256 value) external view {
+        vm.assume(id != bytes4(0));
+        vm.assume(searchId != bytes4(0));
+        vm.assume(id != searchId);
+
+        bytes4[] memory ids = new bytes4[](1);
+        ids[0] = id;
+
+        bytes[] memory datas = new bytes[](1);
+        datas[0] = abi.encodePacked(bytes32(value));
+
+        bytes memory metadata = harness.createMetadata(ids, datas);
+
+        (bool found, bytes memory result) = harness.getDataFor(searchId, metadata);
+        assertFalse(found, "non-existent ID should not be found");
+        assertEq(result.length, 0, "data should be empty");
+    }
+
+    //*********************************************************************//
+    // --- Two Entry Round-Trip ----------------------------------------- //
+    //*********************************************************************//
+
+    /// @notice createMetadata with 2 entries, both are retrievable.
+    function testFuzz_twoEntries_roundTrip(bytes4 id1, bytes4 id2, uint256 value1, uint256 value2) external view {
+        vm.assume(id1 != bytes4(0) && id2 != bytes4(0));
+        vm.assume(id1 != id2);
+
+        bytes4[] memory ids = new bytes4[](2);
+        ids[0] = id1;
+        ids[1] = id2;
+
+        bytes[] memory datas = new bytes[](2);
+        datas[0] = abi.encodePacked(bytes32(value1));
+        datas[1] = abi.encodePacked(bytes32(value2));
+
+        bytes memory metadata = harness.createMetadata(ids, datas);
+
+        // Check first entry
+        (bool found1, bytes memory result1) = harness.getDataFor(id1, metadata);
+        assertTrue(found1, "first ID should be found");
+        assertEq(abi.decode(result1, (uint256)), value1, "first data should match");
+
+        // Check second entry
+        (bool found2, bytes memory result2) = harness.getDataFor(id2, metadata);
+        assertTrue(found2, "second ID should be found");
+        assertEq(abi.decode(result2, (uint256)), value2, "second data should match");
+    }
+
+    //*********************************************************************//
+    // --- addToMetadata Round-Trip ------------------------------------- //
+    //*********************************************************************//
+
+    /// @notice addToMetadata on empty metadata creates valid entry.
+    function testFuzz_addToEmpty_roundTrip(bytes4 id, uint256 value) external view {
+        vm.assume(id != bytes4(0));
+
+        bytes memory empty = new bytes(0);
+        bytes memory dataToAdd = abi.encodePacked(bytes32(value));
+
+        bytes memory metadata = harness.addToMetadata(empty, id, dataToAdd);
+
+        (bool found, bytes memory result) = harness.getDataFor(id, metadata);
+        assertTrue(found, "added ID should be found");
+        assertEq(abi.decode(result, (uint256)), value, "added data should match");
+    }
+
+    /// @notice addToMetadata preserves existing entries.
+    function testFuzz_addPreservesExisting(bytes4 id1, bytes4 id2, uint256 value1, uint256 value2) external view {
+        vm.assume(id1 != bytes4(0) && id2 != bytes4(0));
+        vm.assume(id1 != id2);
+
+        // Create metadata with first entry
+        bytes4[] memory ids = new bytes4[](1);
+        ids[0] = id1;
+
+        bytes[] memory datas = new bytes[](1);
+        datas[0] = abi.encodePacked(bytes32(value1));
+
+        bytes memory metadata = harness.createMetadata(ids, datas);
+
+        // Add second entry
+        metadata = harness.addToMetadata(metadata, id2, abi.encodePacked(bytes32(value2)));
+
+        // Both should be retrievable
+        (bool found1, bytes memory result1) = harness.getDataFor(id1, metadata);
+        assertTrue(found1, "original ID should still be found");
+        assertEq(abi.decode(result1, (uint256)), value1, "original data should be preserved");
+
+        (bool found2, bytes memory result2) = harness.getDataFor(id2, metadata);
+        assertTrue(found2, "added ID should be found");
+        assertEq(abi.decode(result2, (uint256)), value2, "added data should match");
+    }
+
+    //*********************************************************************//
+    // --- Edge Cases --------------------------------------------------- //
+    //*********************************************************************//
+
+    /// @notice Empty/short metadata returns (false, "").
+    function testFuzz_shortMetadata_returnsEmpty(bytes4 id, uint8 length) external view {
+        vm.assume(id != bytes4(0));
+        length = uint8(bound(uint256(length), 0, 37)); // <= MIN_METADATA_LENGTH
+
+        bytes memory shortData = new bytes(length);
+
+        (bool found, bytes memory result) = harness.getDataFor(id, shortData);
+        assertFalse(found, "short metadata should return false");
+        assertEq(result.length, 0, "short metadata should return empty bytes");
+    }
+
+    /// @notice getId produces deterministic results.
+    function testFuzz_getId_deterministic(string memory purpose, address target) external view {
+        bytes4 id1 = harness.getId(purpose, target);
+        bytes4 id2 = harness.getId(purpose, target);
+        assertEq(id1, id2, "same inputs should produce same ID");
+    }
+
+    /// @notice getId with very different targets produces different IDs.
+    /// @dev Only tests addresses that differ in the first 4 bytes to avoid XOR collision.
+    function testFuzz_getId_differentTargets(uint256 seed1, uint256 seed2) external view {
+        vm.assume(seed1 != seed2);
+        address target1 = address(uint160(seed1));
+        address target2 = address(uint160(seed2));
+        vm.assume(target1 != target2);
+
+        bytes4 id1 = harness.getId("test", target1);
+        bytes4 id2 = harness.getId("test", target2);
+
+        // Due to 4-byte truncation, collisions are possible but statistically rare
+        // for truly random addresses. We just verify they're computed without reverting.
+        // If they happen to collide, that's fine - it's a 1/2^32 chance per pair.
+        if (bytes4(bytes20(target1)) != bytes4(bytes20(target2))) {
+            assertTrue(id1 != id2, "IDs with different high-4-byte addresses should differ");
+        }
+    }
+
+    //*********************************************************************//
+    // --- Length Mismatch ---------------------------------------------- //
+    //*********************************************************************//
+
+    /// @notice createMetadata with mismatched lengths reverts.
+    function test_lengthMismatch_reverts() external {
+        bytes4[] memory ids = new bytes4[](2);
+        ids[0] = bytes4(0x11111111);
+        ids[1] = bytes4(0x22222222);
+
+        bytes[] memory datas = new bytes[](1);
+        datas[0] = abi.encodePacked(bytes32(uint256(100)));
+
+        vm.expectRevert(JBMetadataResolver.JBMetadataResolver_LengthMismatch.selector);
+        harness.createMetadata(ids, datas);
+    }
+
+    /// @notice createMetadata with unpadded data reverts.
+    function test_unpaddedData_reverts() external {
+        bytes4[] memory ids = new bytes4[](1);
+        ids[0] = bytes4(0x11111111);
+
+        bytes[] memory datas = new bytes[](1);
+        datas[0] = abi.encodePacked(uint8(42)); // Only 1 byte, not padded
+
+        vm.expectRevert(JBMetadataResolver.JBMetadataResolver_DataNotPadded.selector);
+        harness.createMetadata(ids, datas);
+    }
+}

package/test/units/static/JBMetadataResolver/TestMetadataResolverM20M21.sol

@@ -0,0 +1,245 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBMetadataResolver} from "../../../../src/libraries/JBMetadataResolver.sol";
+
+/// @notice Harness that exposes JBMetadataResolver internals and adds a combined operation
+/// to test memory corruption from _sliceBytes within a single execution context.
+contract M20M21Harness {
+    function createMetadata(bytes4[] memory ids, bytes[] memory datas) external pure returns (bytes memory) {
+        return JBMetadataResolver.createMetadata(ids, datas);
+    }
+
+    function getDataFor(bytes4 id, bytes memory metadata) external pure returns (bool found, bytes memory targetData) {
+        return JBMetadataResolver.getDataFor(id, metadata);
+    }
+
+    function addToMetadata(
+        bytes memory originalMetadata,
+        bytes4 idToAdd,
+        bytes memory dataToAdd
+    )
+        external
+        pure
+        returns (bytes memory)
+    {
+        return JBMetadataResolver.addToMetadata(originalMetadata, idToAdd, dataToAdd);
+    }
+
+    /// @notice Adds an entry then immediately verifies all entries in one execution context.
+    /// This catches memory corruption from _sliceBytes that wouldn't be visible across external calls.
+    function addAndVerifyAll(
+        bytes memory metadata,
+        bytes4 newId,
+        bytes memory newData,
+        bytes4[] memory allIds,
+        bytes32[] memory expectedValues
+    )
+        external
+        pure
+        returns (bool allCorrect)
+    {
+        // Add the new entry — this internally calls _sliceBytes with start > 0
+        bytes memory updated = JBMetadataResolver.addToMetadata(metadata, newId, newData);
+
+        // Verify all entries within the same execution context (same memory space)
+        allCorrect = true;
+        for (uint256 i; i < allIds.length; i++) {
+            (bool found, bytes memory data) = JBMetadataResolver.getDataFor(allIds[i], updated);
+            if (!found) {
+                allCorrect = false;
+                break;
+            }
+            if (
+                keccak256(abi.encodePacked(bytes32(abi.decode(data, (uint256)))))
+                    != keccak256(abi.encodePacked(expectedValues[i]))
+            ) {
+                allCorrect = false;
+                break;
+            }
+        }
+    }
+}
+
+/// @notice Tests for M-20 (_sliceBytes over-copy) and M-21 (addToMetadata offset overflow).
+contract TestMetadataResolverM20M21 is JBTest {
+    M20M21Harness harness;
+
+    function setUp() external {
+        harness = new M20M21Harness();
+    }
+
+    //*********************************************************************//
+    // --- M-20: _sliceBytes memory over-copy --------------------------- //
+    //*********************************************************************//
+
+    /// @notice Verifies that addToMetadata preserves all entries when adding to metadata with
+    /// multiple existing entries. The _sliceBytes call at line 129 uses start > 0, which on
+    /// the buggy code would over-copy and corrupt subsequent memory operations.
+    function test_M20_addToMetadataPreservesAllEntries() external view {
+        bytes4 id1 = bytes4(0x11111111);
+        bytes4 id2 = bytes4(0x22222222);
+        bytes4 id3 = bytes4(0x33333333);
+
+        uint256 val1 = 111;
+        uint256 val2 = 222;
+        uint256 val3 = 333;
+
+        // Create metadata with 2 entries
+        bytes4[] memory ids = new bytes4[](2);
+        ids[0] = id1;
+        ids[1] = id2;
+
+        bytes[] memory datas = new bytes[](2);
+        datas[0] = abi.encodePacked(bytes32(val1));
+        datas[1] = abi.encodePacked(bytes32(val2));
+
+        bytes memory metadata = harness.createMetadata(ids, datas);
+
+        // Add a 3rd entry — this exercises _sliceBytes with start > 0
+        bytes4[] memory allIds = new bytes4[](3);
+        allIds[0] = id1;
+        allIds[1] = id2;
+        allIds[2] = id3;
+
+        bytes32[] memory expectedValues = new bytes32[](3);
+        expectedValues[0] = bytes32(val1);
+        expectedValues[1] = bytes32(val2);
+        expectedValues[2] = bytes32(val3);
+
+        bool allCorrect =
+            harness.addAndVerifyAll(metadata, id3, abi.encodePacked(bytes32(val3)), allIds, expectedValues);
+
+        assertTrue(allCorrect, "All entries should be retrievable after addToMetadata");
+    }
+
+    /// @notice Test with 4 sequential addToMetadata calls, each exercising _sliceBytes.
+    /// More entries = more start > 0 cases = more chances for memory corruption.
+    function test_M20_multipleSequentialAdds() external view {
+        bytes4[5] memory ids =
+            [bytes4(0x11111111), bytes4(0x22222222), bytes4(0x33333333), bytes4(0x44444444), bytes4(0x55555555)];
+        uint256[5] memory vals = [uint256(100), uint256(200), uint256(300), uint256(400), uint256(500)];
+
+        // Start with 1 entry via createMetadata
+        bytes4[] memory initIds = new bytes4[](1);
+        initIds[0] = ids[0];
+        bytes[] memory initDatas = new bytes[](1);
+        initDatas[0] = abi.encodePacked(bytes32(vals[0]));
+        bytes memory metadata = harness.createMetadata(initIds, initDatas);
+
+        // Add 4 more entries sequentially
+        for (uint256 i = 1; i < 5; i++) {
+            metadata = harness.addToMetadata(metadata, ids[i], abi.encodePacked(bytes32(vals[i])));
+        }
+
+        // Verify ALL entries are still correct
+        for (uint256 i; i < 5; i++) {
+            (bool found, bytes memory data) = harness.getDataFor(ids[i], metadata);
+            assertTrue(found, string.concat("Entry ", vm.toString(i), " should be found"));
+            assertEq(abi.decode(data, (uint256)), vals[i], string.concat("Entry ", vm.toString(i), " data mismatch"));
+        }
+    }
+
+    /// @notice Verify that getDataFor returns the exact expected length for non-first entries.
+    /// On buggy code, _sliceBytes copies more than needed, but the returned length should still
+    /// be correct. This test verifies both length and content.
+    function test_M20_getDataForReturnsCorrectLength() external view {
+        bytes4 id1 = bytes4(0xAAAAAAAA);
+        bytes4 id2 = bytes4(0xBBBBBBBB);
+
+        // Entry 1: 2 words (64 bytes). Entry 2: 1 word (32 bytes).
+        bytes4[] memory ids = new bytes4[](2);
+        ids[0] = id1;
+        ids[1] = id2;
+
+        bytes[] memory datas = new bytes[](2);
+        datas[0] = abi.encodePacked(bytes32(uint256(0xAA)), bytes32(uint256(0xBB))); // 64 bytes
+        datas[1] = abi.encodePacked(bytes32(uint256(0xCC))); // 32 bytes
+
+        bytes memory metadata = harness.createMetadata(ids, datas);
+
+        // Get entry 1 (first entry, start = firstOffset * 32)
+        (bool found1, bytes memory data1) = harness.getDataFor(id1, metadata);
+        assertTrue(found1, "Entry 1 should be found");
+        assertEq(data1.length, 64, "Entry 1 should be 64 bytes");
+
+        // Get entry 2 (second entry, start > firstOffset * 32)
+        (bool found2, bytes memory data2) = harness.getDataFor(id2, metadata);
+        assertTrue(found2, "Entry 2 should be found");
+        assertEq(data2.length, 32, "Entry 2 should be exactly 32 bytes");
+        assertEq(abi.decode(data2, (uint256)), 0xCC, "Entry 2 data should be 0xCC");
+    }
+
+    //*********************************************************************//
+    // --- M-21: addToMetadata offset overflow -------------------------- //
+    //*********************************************************************//
+
+    /// @notice Verifies that addToMetadata reverts when the new offset would exceed 255.
+    /// Uses 6 entries (table = 1 word, 30 bytes) with data totaling 253 words → total 255 words.
+    /// Adding a 7th entry via addToMetadata forces the table from 1→2 words, incrementing all
+    /// offsets by 1. This pushes newOffset from 255 to 256, triggering the overflow check.
+    function test_M21_addToMetadataRevertsOnOffsetOverflow() external {
+        // 6 entries: table = ceil(6*5/32) = 1 word. firstOffset = 2.
+        // 5 entries × 42 words + 1 entry × 43 words = 253 words of data.
+        // Total = 1 (reserved) + 1 (table) + 253 (data) = 255 words.
+        // createMetadata final offset check: 255 > 255 → false → succeeds.
+        bytes4[] memory ids = new bytes4[](6);
+        ids[0] = bytes4(0x11111111);
+        ids[1] = bytes4(0x22222222);
+        ids[2] = bytes4(0x33333333);
+        ids[3] = bytes4(0x44444444);
+        ids[4] = bytes4(0x55555555);
+        ids[5] = bytes4(0x66666666);
+
+        bytes[] memory datas = new bytes[](6);
+        // 5 entries of 42 words (1344 bytes) + 1 entry of 43 words (1376 bytes)
+        for (uint256 i; i < 5; i++) {
+            datas[i] = new bytes(1344);
+            datas[i][0] = bytes1(uint8(i + 1));
+        }
+        datas[5] = new bytes(1376);
+        datas[5][0] = 0x06;
+
+        bytes memory metadata = harness.createMetadata(ids, datas);
+
+        // Adding a 7th entry: table grows from 30 bytes (1 word) to 35 bytes (2 words).
+        // All offsets += 1. lastOffset (212) becomes 213.
+        // newOffset = 213 + 43 = 256 > 255 → revert.
+        vm.expectRevert(JBMetadataResolver.JBMetadataResolver_MetadataTooLong.selector);
+        harness.addToMetadata(metadata, bytes4(0x77777777), abi.encodePacked(bytes32(uint256(7))));
+    }
+
+    /// @notice Verifies that addToMetadata works when the offset is exactly at the boundary (255).
+    /// Same 6-entry table expansion setup but with 1 less data word (total 254 words),
+    /// so the expanded offset is exactly 255 — the maximum valid value.
+    function test_M21_addToMetadataSucceedsAtBoundary() external view {
+        // 6 entries × 42 words each = 252 words of data.
+        // Total = 1 (reserved) + 1 (table) + 252 (data) = 254 words.
+        bytes4[] memory ids = new bytes4[](6);
+        ids[0] = bytes4(0x11111111);
+        ids[1] = bytes4(0x22222222);
+        ids[2] = bytes4(0x33333333);
+        ids[3] = bytes4(0x44444444);
+        ids[4] = bytes4(0x55555555);
+        ids[5] = bytes4(0x66666666);
+
+        bytes[] memory datas = new bytes[](6);
+        for (uint256 i; i < 6; i++) {
+            datas[i] = new bytes(1344); // 42 words each
+            datas[i][0] = bytes1(uint8(i + 1));
+        }
+
+        bytes memory metadata = harness.createMetadata(ids, datas);
+
+        // Adding 7th entry: table expands, all offsets += 1.
+        // lastOffset (212) becomes 213. newOffset = 213 + 42 = 255 ≤ 255 → succeeds.
+        bytes memory updated =
+            harness.addToMetadata(metadata, bytes4(0x77777777), abi.encodePacked(bytes32(uint256(7))));
+
+        // Verify the new entry is retrievable.
+        (bool found, bytes memory data) = harness.getDataFor(bytes4(0x77777777), updated);
+        assertTrue(found, "New entry should be found at boundary offset 255");
+        assertEq(abi.decode(data, (uint256)), 7, "Boundary entry data should match");
+    }
+}

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

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+
+/*
+Contract that deploys a target contract with other mock contracts to satisfy the constructor.
+Tests relative to this contract will be dependent on mock calls/emits and stdStorage.
+*/
+contract JBMultiTerminalSetup is JBTest {
+    // Target Contract
+    IJBMultiTerminal public _terminal;
+    MetadataResolverHelper public _metadataHelper;
+
+    // Mocks
+    IJBPermissions public permissions = IJBPermissions(makeAddr("permissions"));
+    IJBProjects public projects = IJBProjects(makeAddr("projects"));
+    IJBDirectory public directory = IJBDirectory(makeAddr("directory"));
+    IJBRulesets public rulesets = IJBRulesets(makeAddr("rulesets"));
+    IJBTokens public tokens = IJBTokens(makeAddr("tokens"));
+    IJBSplits public splits = IJBSplits(makeAddr("splits"));
+    IJBTerminalStore public store = IJBTerminalStore(makeAddr("store"));
+    IJBFeelessAddresses public feelessAddresses = IJBFeelessAddresses(makeAddr("feeless"));
+    IPermit2 public permit2 = IPermit2(makeAddr("permit2"));
+    address trustedForwarder = makeAddr("forwarder");
+
+    function multiTerminalSetup() public virtual {
+        // Constructor will call to find directory and rulesets from the terminal store
+        mockExpect(address(store), abi.encodeCall(IJBTerminalStore.DIRECTORY, ()), abi.encode(address(directory)));
+        mockExpect(address(store), abi.encodeCall(IJBTerminalStore.RULESETS, ()), abi.encode(address(rulesets)));
+
+        // Instantiate the contract being tested
+        _terminal = new JBMultiTerminal(
+            feelessAddresses, permissions, projects, splits, store, tokens, permit2, trustedForwarder
+        );
+
+        _metadataHelper = new MetadataResolverHelper();
+    }
+}

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

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBMultiTerminalSetup} from "./JBMultiTerminalSetup.sol";
+
+contract TestAccountingContextsOf_Local is JBMultiTerminalSetup {
+    uint256 _projectId = 1;
+    address _usdc = makeAddr("USDC");
+    uint256 _usdcCurrency = uint32(uint160(_usdc));
+
+    function setUp() public {
+        super.multiTerminalSetup();
+    }
+
+    function test_WhenAccountingContextsAreSet() external {
+        // it will return contexts
+
+        // mock call to JBProjects ownerOf(_projectId)
+        bytes memory _projectsCall = abi.encodeCall(IERC721.ownerOf, (_projectId));
+        bytes memory _projectsCallReturn = abi.encode(address(this));
+        mockExpect(address(projects), _projectsCall, _projectsCallReturn);
+
+        // mock call to JBDirectory controllerOf(_projectId)
+        mockExpect(
+            address(directory), abi.encodeCall(IJBDirectory.controllerOf, (_projectId)), abi.encode(address(this))
+        );
+
+        // mock call to tokens decimals()
+        mockExpect(_usdc, abi.encodeCall(IERC20Metadata.decimals, ()), abi.encode(6));
+
+        // setup: return data
+        JBRuleset memory ruleset = JBRuleset({
+            cycleNumber: 1,
+            id: 0,
+            basedOnId: 0,
+            start: 0,
+            duration: 0,
+            weight: 0,
+            weightCutPercent: 0,
+            approvalHook: IJBRulesetApprovalHook(address(0)),
+            metadata: 0
+        });
+
+        // mock call to rulesets currentOf returning 0 to bypass ruleset checking
+        mockExpect(address(rulesets), abi.encodeCall(IJBRulesets.currentOf, (_projectId)), abi.encode(ruleset));
+
+        // call params
+        JBAccountingContext[] memory _tokens = new JBAccountingContext[](1);
+        _tokens[0] = JBAccountingContext({token: _usdc, decimals: 6, currency: uint32(uint160(_usdc))});
+
+        _terminal.addAccountingContextsFor(_projectId, _tokens);
+
+        JBAccountingContext[] memory _storedContexts = _terminal.accountingContextsOf(_projectId);
+        assertEq(_storedContexts[0].currency, _usdcCurrency);
+        assertEq(_storedContexts[0].token, _usdc);
+        assertEq(_storedContexts[0].decimals, 6);
+    }
+
+    function test_WhenAccountingContextsAreNotSet() external view {
+        // it will return an empty array
+        JBAccountingContext[] memory _storedContexts = _terminal.accountingContextsOf(_projectId);
+        assertEq(_storedContexts.length, 0);
+    }
+}