@bananapus/core-v6 0.0.36 → 0.0.38

package/test/units/static/JBFundAccessLimits/TestSurplusAllowancesOf.sol

@@ -1,102 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-import {IJBDirectory} from "../../../../src/interfaces/IJBDirectory.sol";
-import {JBConstants} from "../../../../src/libraries/JBConstants.sol";
-import {JBCurrencyAmount} from "../../../../src/structs/JBCurrencyAmount.sol";
-import {JBFundAccessLimitGroup} from "../../../../src/structs/JBFundAccessLimitGroup.sol";
-import {JBFundAccessSetup} from "./JBFundAccessSetup.sol";
-
-contract TestSurplusAllowancesOf_Local is JBFundAccessSetup {
-    uint256 _projectId = 1;
-    address _terminal = address(1);
-    address _terminal2 = address(2);
-    address _someToken = makeAddr("someToken");
-
-    function setUp() public {
-        super.fundAccessSetup();
-    }
-
-    modifier whenAProjectHasSpecifiedSurplusAllowances() {
-        bytes memory _controllerCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
-        bytes memory _return = abi.encode(address(this));
-
-        mockExpect(address(directory), _controllerCall, _return);
-
-        // Fund Access config
-        JBFundAccessLimitGroup[] memory _fundAccessLimitGroup = new JBFundAccessLimitGroup[](2);
-        {
-            // Specify a payout limit.
-            JBCurrencyAmount[] memory _payoutLimits = new JBCurrencyAmount[](0);
-
-            // Specify a surplus allowance.
-            JBCurrencyAmount[] memory _surplusAllowances = new JBCurrencyAmount[](2);
-            _surplusAllowances[0] =
-                JBCurrencyAmount({amount: 1e18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))});
-
-            // forge-lint: disable-next-line(unsafe-typecast)
-            _surplusAllowances[1] = JBCurrencyAmount({amount: 2e18, currency: uint32(uint160(_someToken))});
-
-            _fundAccessLimitGroup[0] = JBFundAccessLimitGroup({
-                terminal: _terminal,
-                token: JBConstants.NATIVE_TOKEN,
-                payoutLimits: _payoutLimits,
-                surplusAllowances: _surplusAllowances
-            });
-
-            _fundAccessLimitGroup[1] = JBFundAccessLimitGroup({
-                terminal: _terminal2,
-                token: _someToken,
-                payoutLimits: _payoutLimits,
-                surplusAllowances: _surplusAllowances
-            });
-        }
-
-        _fundAccess.setFundAccessLimitsFor(_projectId, block.timestamp, _fundAccessLimitGroup);
-        _fundAccess.setFundAccessLimitsFor(_projectId, block.timestamp + 1, _fundAccessLimitGroup);
-
-        _;
-    }
-
-    function test_GivenTheyAreSpecifiedForASpecificRuleset() external whenAProjectHasSpecifiedSurplusAllowances {
-        // it will return them
-
-        JBCurrencyAmount[] memory surplusLimits =
-            _fundAccess.surplusAllowancesOf(_projectId, block.timestamp, _terminal, JBConstants.NATIVE_TOKEN);
-
-        JBCurrencyAmount[] memory surplusLimits2 =
-            _fundAccess.surplusAllowancesOf(_projectId, block.timestamp + 1, _terminal, JBConstants.NATIVE_TOKEN);
-
-        assertEq(surplusLimits[0].currency, uint32(uint160(JBConstants.NATIVE_TOKEN)));
-        assertEq(surplusLimits[0].amount, 1e18);
-        // forge-lint: disable-next-line(unsafe-typecast)
-        assertEq(surplusLimits[1].currency, uint32(uint160(_someToken)));
-        assertEq(surplusLimits[1].amount, 2e18);
-
-        assertEq(surplusLimits2[0].currency, uint32(uint160(JBConstants.NATIVE_TOKEN)));
-        assertEq(surplusLimits2[0].amount, 1e18);
-        // forge-lint: disable-next-line(unsafe-typecast)
-        assertEq(surplusLimits2[1].currency, uint32(uint160(_someToken)));
-        assertEq(surplusLimits2[1].amount, 2e18);
-    }
-
-    function test_GivenTheyAreSpecifiedForASpecificTerminal() external whenAProjectHasSpecifiedSurplusAllowances {
-        // it will return them
-
-        JBCurrencyAmount[] memory surplusLimits =
-            _fundAccess.surplusAllowancesOf(_projectId, block.timestamp, _terminal2, _someToken);
-
-        assertEq(surplusLimits[0].currency, uint32(uint160(JBConstants.NATIVE_TOKEN)));
-        assertEq(surplusLimits[0].amount, 1e18);
-    }
-
-    function test_GivenTheyAreSpecifiedForASpecificToken() external whenAProjectHasSpecifiedSurplusAllowances {
-        // it will return them
-
-        JBCurrencyAmount[] memory surplusLimits =
-            _fundAccess.surplusAllowancesOf(_projectId, block.timestamp, _terminal, JBConstants.NATIVE_TOKEN);
-
-        assertEq(surplusLimits[0].currency, uint32(uint160(JBConstants.NATIVE_TOKEN)));
-        assertEq(surplusLimits[0].amount, 1e18);
-    }
-}

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

@@ -1,90 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-import {JBTest} from "../../../helpers/JBTest.sol";
-import {JBMetadataResolver} from "../../../../src/libraries/JBMetadataResolver.sol";
-
-contract TestGetDataFor_Local is JBTest {
-    bytes4 _id1 = bytes4(0x10101010);
-    bytes4 _id2 = bytes4(0x20202020);
-
-    function setUp() external {}
-
-    function test_WhenMetadataLengthLTEQMIN_METADATA_LENGTH() external view {
-        // it will return false and empty bytes
-
-        // malformed data only contains the padding intended for the protocol
-        bytes memory _malformed = abi.encodePacked(bytes32(uint256(type(uint256).max)));
-
-        (bool _found, bytes memory _data) = JBMetadataResolver.getDataFor(_id1, _malformed);
-
-        // check
-        assertEq(_found, false);
-        assertEq("", _data);
-    }
-
-    // forge-lint: disable-next-line(mixed-case-function)
-    modifier whenMetadataLengthGTMIN_METADATA_LENGTH() {
-        _;
-    }
-
-    function test_GivenIdIsFound() external view whenMetadataLengthGTMIN_METADATA_LENGTH {
-        // it will return found EQ true and targetData
-
-        uint256 _data1 = 10_000_000;
-        bytes memory _data2 = new bytes(100);
-
-        // malformed data only contains the padding intended for the protocol
-        bytes memory _metadata = abi.encodePacked(
-            // -- offset 0 --
-            bytes32(uint256(type(uint256).max)), // First 32B reserved
-            // -- offset 1 --
-            _id1, // First id
-            uint8(2), // First data offset == 2
-            _id2, // Second id == _id
-            uint8(3), // Second data offset == 3
-            bytes22(0), // Rest of the word is 0-padded
-            // -- offset 2 --
-            _data1, // First data
-            // -- offset 3 --
-            _data2 // Second data
-        );
-
-        (bool _found, bytes memory _returnedData) = JBMetadataResolver.getDataFor(_id1, _metadata);
-
-        // check
-        assertEq(_found, true);
-        assertEq(abi.decode(_returnedData, (uint256)), _data1);
-    }
-
-    function test_GivenIdIsNotFound() external view whenMetadataLengthGTMIN_METADATA_LENGTH {
-        // it will return found EQ false and empty bytes targetData
-
-        uint256 _data1 = 10_000_000;
-        bytes memory _data2 = new bytes(100);
-
-        // malformed data only contains the padding intended for the protocol
-        bytes memory _metadata = abi.encodePacked(
-            // -- offset 0 --
-            bytes32(uint256(type(uint256).max)), // First 32B reserved
-            // -- offset 1 --
-            _id1, // First id
-            uint8(2), // First data offset == 2
-            _id2, // Second id == _id
-            uint8(3), // Second data offset == 3
-            bytes22(0), // Rest of the word is 0-padded
-            // -- offset 2 --
-            _data1, // First data
-            // -- offset 3 --
-            _data2 // Second data
-        );
-
-        bytes4 _invalidId = bytes4(0x40404040);
-
-        (bool _found, bytes memory _returnedData) = JBMetadataResolver.getDataFor(_invalidId, _metadata);
-
-        // check
-        assertEq(_found, false);
-        assertEq("", _returnedData);
-    }
-}

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

@@ -1,247 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-import {JBTest} from "../../../helpers/JBTest.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 MetadataResolverEdgeCaseHarness {
-    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 _sliceBytes over-copy and addToMetadata offset overflow.
-contract TestMetadataResolverEdgeCases is JBTest {
-    MetadataResolverEdgeCaseHarness harness;
-
-    function setUp() external {
-        harness = new MetadataResolverEdgeCaseHarness();
-    }
-
-    //*********************************************************************//
-    // --- _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_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_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_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");
-    }
-
-    //*********************************************************************//
-    // --- 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_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);
-            // forge-lint: disable-next-line(unsafe-typecast)
-            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_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
-            // forge-lint: disable-next-line(unsafe-typecast)
-            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/JBMetadataResolver/TestMetadataResolverFuzz.sol

@@ -1,229 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-import {JBTest} from "../../../helpers/JBTest.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);
-        // forge-lint: disable-next-line(unsafe-typecast)
-        address target1 = address(uint160(seed1));
-        // forge-lint: disable-next-line(unsafe-typecast)
-        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);
-    }
-}