@bananapus/core-v6 0.0.1

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

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBFundAccessSetup} from "./JBFundAccessSetup.sol";
+
+contract TestPayoutLimitOf_Local is JBFundAccessSetup {
+    uint256 _projectId = 1;
+    uint256 _ruleset = block.timestamp;
+    uint224 _payoutLimit = 1e18;
+    uint32 _currency = uint32(uint160(JBConstants.NATIVE_TOKEN));
+    address _terminal = address(1);
+    address _token = JBConstants.NATIVE_TOKEN;
+
+    function setUp() public {
+        super.fundAccessSetup();
+
+        // Fund Access config
+        JBFundAccessLimitGroup[] memory _fundAccessLimitGroup = new JBFundAccessLimitGroup[](1);
+        {
+            // Specify a payout limit.
+            JBCurrencyAmount[] memory _payoutLimits = new JBCurrencyAmount[](1);
+            _payoutLimits[0] =
+                JBCurrencyAmount({amount: _payoutLimit, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))});
+
+            // Specify a surplus allowance.
+            JBCurrencyAmount[] memory _surplusAllowances = new JBCurrencyAmount[](0);
+
+            _fundAccessLimitGroup[0] = JBFundAccessLimitGroup({
+                terminal: address(_terminal),
+                token: JBConstants.NATIVE_TOKEN,
+                payoutLimits: _payoutLimits,
+                surplusAllowances: _surplusAllowances
+            });
+        }
+
+        bytes memory _controllerCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _return = abi.encode(address(this));
+
+        mockExpect(address(directory), _controllerCall, _return);
+
+        _fundAccess.setFundAccessLimitsFor(_projectId, _ruleset, _fundAccessLimitGroup);
+    }
+
+    function test_WhenTheProjectHasTheSpecificPayoutLimit() external view {
+        // it will return the uint256 payoutLimit
+        uint256 _returnedLimit = _fundAccess.payoutLimitOf(_projectId, _ruleset, _terminal, _token, _currency);
+        assertEq(_returnedLimit, _payoutLimit);
+    }
+
+    function test_WhenTheProjectDoesntHaveTheSpecificPayoutLimit() external view {
+        // it will return 0
+        uint256 empty = _fundAccess.payoutLimitOf(1, 1, address(1), address(2), 1);
+        assertEq(empty, 0);
+    }
+}

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

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBFundAccessSetup} from "./JBFundAccessSetup.sol";
+
+contract TestPayoutLimitsOf_Local is JBFundAccessSetup {
+    uint256 _projectId = 1;
+    uint256 _ruleset = block.timestamp;
+    uint224 _payoutLimit = 1e18;
+    uint224 _payoutLimit2 = 1e6;
+    uint32 _currency = uint32(uint160(JBConstants.NATIVE_TOKEN));
+    address _terminal = address(1);
+    address _terminal2 = address(2);
+    address _someToken = makeAddr("sometoken");
+
+    function setUp() public {
+        super.fundAccessSetup();
+    }
+
+    modifier whenAProjectHasPayoutLimits() {
+        // Fund Access config
+        JBFundAccessLimitGroup[] memory _fundAccessLimitGroup = new JBFundAccessLimitGroup[](2);
+        {
+            // Specify a payout limit.
+            JBCurrencyAmount[] memory _payoutLimits = new JBCurrencyAmount[](2);
+            _payoutLimits[0] =
+                JBCurrencyAmount({amount: _payoutLimit, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))});
+
+            // Specify a second payout limit.
+            _payoutLimits[1] = JBCurrencyAmount({amount: _payoutLimit2, currency: uint32(uint160(_someToken))});
+
+            // Specify a surplus allowance.
+            JBCurrencyAmount[] memory _surplusAllowances = new JBCurrencyAmount[](0);
+
+            _fundAccessLimitGroup[0] = JBFundAccessLimitGroup({
+                terminal: address(_terminal),
+                token: JBConstants.NATIVE_TOKEN,
+                payoutLimits: _payoutLimits,
+                surplusAllowances: _surplusAllowances
+            });
+
+            _fundAccessLimitGroup[1] = JBFundAccessLimitGroup({
+                terminal: address(_terminal2),
+                token: JBConstants.NATIVE_TOKEN,
+                payoutLimits: _payoutLimits,
+                surplusAllowances: _surplusAllowances
+            });
+        }
+
+        bytes memory _controllerCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _return = abi.encode(address(this));
+
+        mockExpect(address(directory), _controllerCall, _return);
+
+        _fundAccess.setFundAccessLimitsFor(_projectId, _ruleset, _fundAccessLimitGroup);
+        _fundAccess.setFundAccessLimitsFor(_projectId, _ruleset + 1, _fundAccessLimitGroup);
+        _;
+    }
+
+    function test_GivenTheyAreConfiguredForASpecificToken() external whenAProjectHasPayoutLimits {
+        // it will return them
+
+        JBCurrencyAmount[] memory payoutLimits =
+            _fundAccess.payoutLimitsOf(_projectId, _ruleset, _terminal, JBConstants.NATIVE_TOKEN);
+
+        assertEq(payoutLimits[0].currency, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertEq(payoutLimits[0].amount, _payoutLimit);
+        assertEq(payoutLimits[1].currency, uint32(uint160(_someToken)));
+        assertEq(payoutLimits[1].amount, _payoutLimit2);
+    }
+
+    function test_GivenTheyAreConfiguredForASpecificTerminal() external whenAProjectHasPayoutLimits {
+        // it will return them
+        JBCurrencyAmount[] memory payoutLimits =
+            _fundAccess.payoutLimitsOf(_projectId, _ruleset, _terminal2, JBConstants.NATIVE_TOKEN);
+
+        assertEq(payoutLimits[0].currency, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertEq(payoutLimits[0].amount, _payoutLimit);
+        assertEq(payoutLimits[1].currency, uint32(uint160(_someToken)));
+        assertEq(payoutLimits[1].amount, _payoutLimit2);
+    }
+
+    function test_GivenTheyAreConfiguredForASpecificRulesetId() external whenAProjectHasPayoutLimits {
+        // it will return them
+        JBCurrencyAmount[] memory payoutLimits =
+            _fundAccess.payoutLimitsOf(_projectId, _ruleset + 1, _terminal2, JBConstants.NATIVE_TOKEN);
+
+        assertEq(payoutLimits[0].currency, uint32(uint160(JBConstants.NATIVE_TOKEN)));
+        assertEq(payoutLimits[0].amount, _payoutLimit);
+        assertEq(payoutLimits[1].currency, uint32(uint160(_someToken)));
+        assertEq(payoutLimits[1].amount, _payoutLimit2);
+    }
+}

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

@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBFundAccessSetup} from "./JBFundAccessSetup.sol";
+
+contract TestSetFundAccessLimitsFor_Local is JBFundAccessSetup {
+    uint256 _projectId = 1;
+    uint256 _ruleset = block.timestamp;
+    uint32 _validCurrency = uint32(uint160(JBConstants.NATIVE_TOKEN));
+    address _terminal = address(1);
+    address _terminal2 = address(2);
+    address _someToken = makeAddr("sometoken");
+    uint224 _validLimit = 1e18;
+
+    function setUp() public {
+        super.fundAccessSetup();
+    }
+
+    function test_WhenCallerIsNotController() external {
+        // it will revert
+
+        bytes memory _controllerCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _return = abi.encode(address(makeAddr("notThisContract")));
+
+        mockExpect(address(directory), _controllerCall, _return);
+
+        // Fund Access config
+        JBFundAccessLimitGroup[] memory _fundAccessLimitGroup = new JBFundAccessLimitGroup[](2);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                JBControlled.JBControlled_ControllerUnauthorized.selector, address(makeAddr("notThisContract"))
+            )
+        );
+        _fundAccess.setFundAccessLimitsFor(_projectId, _ruleset, _fundAccessLimitGroup);
+    }
+
+    modifier whenCallerIsControllerOfProject() {
+        bytes memory _controllerCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _return = abi.encode(address(this));
+
+        mockExpect(address(directory), _controllerCall, _return);
+        _;
+    }
+
+    function test_GivenPayoutLimitCurrencyIsNotGivenInAscendingOrder() external whenCallerIsControllerOfProject {
+        // it will revert INVALID_PAYOUT_LIMIT_CURRENCY_ORDERING
+
+        // Fund Access config
+        JBFundAccessLimitGroup[] memory _fundAccessLimitGroup = new JBFundAccessLimitGroup[](2);
+        {
+            // Specify a payout limit.
+            JBCurrencyAmount[] memory _payoutLimits = new JBCurrencyAmount[](2);
+            _payoutLimits[0] = JBCurrencyAmount({amount: _validLimit, currency: type(uint32).max});
+
+            // Specify a second payout limit.
+            _payoutLimits[1] =
+                JBCurrencyAmount({amount: _validLimit, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))});
+
+            // Specify a surplus allowance.
+            JBCurrencyAmount[] memory _surplusAllowances = new JBCurrencyAmount[](0);
+
+            _fundAccessLimitGroup[0] = JBFundAccessLimitGroup({
+                terminal: address(_terminal),
+                token: JBConstants.NATIVE_TOKEN,
+                payoutLimits: _payoutLimits,
+                surplusAllowances: _surplusAllowances
+            });
+        }
+
+        vm.expectRevert(JBFundAccessLimits.JBFundAccessLimits_InvalidPayoutLimitCurrencyOrdering.selector);
+        _fundAccess.setFundAccessLimitsFor(_projectId, _ruleset, _fundAccessLimitGroup);
+    }
+
+    function test_GivenSurplusAllowanceCurrenciesAreNotAscendingOrder() external whenCallerIsControllerOfProject {
+        // it will revert INVALID_SURPLUS_ALLOWANCE_CURRENCY_ORDERING
+
+        // Fund Access config
+        JBFundAccessLimitGroup[] memory _fundAccessLimitGroup = new JBFundAccessLimitGroup[](2);
+        {
+            // Specify a payout limit.
+            JBCurrencyAmount[] memory _payoutLimits = new JBCurrencyAmount[](1);
+            _payoutLimits[0] = JBCurrencyAmount({amount: _validLimit, currency: _validCurrency});
+
+            // Specify a surplus allowance.
+            JBCurrencyAmount[] memory _surplusAllowances = new JBCurrencyAmount[](2);
+            _surplusAllowances[0] = JBCurrencyAmount({amount: _validLimit, currency: type(uint32).max});
+
+            _surplusAllowances[1] = JBCurrencyAmount({amount: _validLimit, currency: _validCurrency});
+
+            _fundAccessLimitGroup[0] = JBFundAccessLimitGroup({
+                terminal: address(_terminal),
+                token: JBConstants.NATIVE_TOKEN,
+                payoutLimits: _payoutLimits,
+                surplusAllowances: _surplusAllowances
+            });
+        }
+
+        vm.expectRevert(JBFundAccessLimits.JBFundAccessLimits_InvalidSurplusAllowanceCurrencyOrdering.selector);
+        _fundAccess.setFundAccessLimitsFor(_projectId, _ruleset, _fundAccessLimitGroup);
+    }
+
+    function test_GivenValidConfig() external whenCallerIsControllerOfProject {
+        // it will set packed properties and emit SetFundAccessLimits
+
+        // Fund Access config
+        JBFundAccessLimitGroup[] memory _fundAccessLimitGroup = new JBFundAccessLimitGroup[](2);
+        {
+            // Specify a payout limit.
+            JBCurrencyAmount[] memory _payoutLimits = new JBCurrencyAmount[](2);
+            _payoutLimits[0] =
+                JBCurrencyAmount({amount: _validLimit, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))});
+
+            // Specify a second payout limit.
+            _payoutLimits[1] = JBCurrencyAmount({amount: _validLimit, currency: uint32(uint160(_someToken))});
+
+            // Specify a surplus allowance.
+            JBCurrencyAmount[] memory _surplusAllowances = new JBCurrencyAmount[](0);
+
+            _fundAccessLimitGroup[0] = JBFundAccessLimitGroup({
+                terminal: address(_terminal),
+                token: JBConstants.NATIVE_TOKEN,
+                payoutLimits: _payoutLimits,
+                surplusAllowances: _surplusAllowances
+            });
+
+            _fundAccessLimitGroup[1] = JBFundAccessLimitGroup({
+                terminal: address(_terminal2),
+                token: JBConstants.NATIVE_TOKEN,
+                payoutLimits: _payoutLimits,
+                surplusAllowances: _surplusAllowances
+            });
+        }
+
+        vm.expectEmit();
+        emit IJBFundAccessLimits.SetFundAccessLimits(_ruleset, _projectId, _fundAccessLimitGroup[0], address(this));
+
+        vm.expectEmit();
+        emit IJBFundAccessLimits.SetFundAccessLimits(_ruleset, _projectId, _fundAccessLimitGroup[1], address(this));
+
+        _fundAccess.setFundAccessLimitsFor(_projectId, _ruleset, _fundAccessLimitGroup);
+    }
+
+    function test_GivenValidConfigWithLimitsZero() external whenCallerIsControllerOfProject {
+        // it will set packed properties and emit SetFundAccessLimits
+
+        // Fund Access config
+        JBFundAccessLimitGroup[] memory _fundAccessLimitGroup = new JBFundAccessLimitGroup[](2);
+        {
+            // Specify a payout limit.
+            JBCurrencyAmount[] memory _payoutLimits = new JBCurrencyAmount[](1);
+            _payoutLimits[0] = JBCurrencyAmount({amount: 0, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))});
+
+            // Specify a surplus allowance.
+            JBCurrencyAmount[] memory _surplusAllowances = new JBCurrencyAmount[](1);
+            _surplusAllowances[0] = JBCurrencyAmount({amount: 0, currency: type(uint32).max});
+
+            _fundAccessLimitGroup[0] = JBFundAccessLimitGroup({
+                terminal: address(_terminal),
+                token: JBConstants.NATIVE_TOKEN,
+                payoutLimits: _payoutLimits,
+                surplusAllowances: _surplusAllowances
+            });
+
+            _fundAccessLimitGroup[1] = JBFundAccessLimitGroup({
+                terminal: address(_terminal2),
+                token: JBConstants.NATIVE_TOKEN,
+                payoutLimits: _payoutLimits,
+                surplusAllowances: _surplusAllowances
+            });
+        }
+
+        vm.expectEmit();
+        emit IJBFundAccessLimits.SetFundAccessLimits(_ruleset, _projectId, _fundAccessLimitGroup[0], address(this));
+
+        vm.expectEmit();
+        emit IJBFundAccessLimits.SetFundAccessLimits(_ruleset, _projectId, _fundAccessLimitGroup[1], address(this));
+
+        _fundAccess.setFundAccessLimitsFor(_projectId, _ruleset, _fundAccessLimitGroup);
+    }
+}

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

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBFundAccessSetup} from "./JBFundAccessSetup.sol";
+
+contract TestSurplusAllowanceOf_Local is JBFundAccessSetup {
+    uint256 _projectId = 1;
+    address _terminal = address(1);
+
+    function setUp() public {
+        super.fundAccessSetup();
+    }
+
+    modifier whenCallerIsControllerOfProject() {
+        bytes memory _controllerCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _return = abi.encode(address(this));
+
+        mockExpect(address(directory), _controllerCall, _return);
+        _;
+    }
+
+    function test_WhenAProjectHasTheSpecificSurplusConfigured() external whenCallerIsControllerOfProject {
+        // it will return uint256 surplusAllowance
+
+        // 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[](1);
+            _surplusAllowances[0] =
+                JBCurrencyAmount({amount: 1e18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))});
+
+            _fundAccessLimitGroup[0] = JBFundAccessLimitGroup({
+                terminal: _terminal,
+                token: JBConstants.NATIVE_TOKEN,
+                payoutLimits: _payoutLimits,
+                surplusAllowances: _surplusAllowances
+            });
+        }
+
+        _fundAccess.setFundAccessLimitsFor(_projectId, block.timestamp, _fundAccessLimitGroup);
+
+        uint256 _returned = _fundAccess.surplusAllowanceOf(
+            _projectId, block.timestamp, _terminal, JBConstants.NATIVE_TOKEN, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+        assertEq(_returned, 1e18);
+    }
+
+    function test_WhenItDoesntHaveTheSpecificSurplusConfigured() external view {
+        // it will return 0
+
+        uint256 _returned = _fundAccess.surplusAllowanceOf(
+            _projectId, block.timestamp, _terminal, JBConstants.NATIVE_TOKEN, uint32(uint160(JBConstants.NATIVE_TOKEN))
+        );
+        assertEq(_returned, 0);
+    }
+}

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

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.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))});
+
+            _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);
+        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);
+        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

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.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);
+    }
+
+    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);
+    }
+}