@bananapus/core-v6 0.0.1

package/test/units/static/JBERC20/JBERC20Setup.sol

@@ -0,0 +1,20 @@
+// 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 JBERC20Setup is JBTest {
+    address _owner = makeAddr("owner");
+
+    // Target Contract
+    IJBToken public _erc20;
+
+    function erc20Setup() public virtual {
+        // Instantiate the contract being tested
+        _erc20 = new JBERC20();
+    }
+}

package/test/units/static/JBERC20/SigUtils.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+contract SigUtils {
+    bytes32 internal DOMAIN_SEPARATOR;
+
+    constructor(bytes32 _DOMAIN_SEPARATOR) {
+        DOMAIN_SEPARATOR = _DOMAIN_SEPARATOR;
+    }
+
+    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
+    bytes32 private constant PERMIT_TYPEHASH =
+        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
+
+    struct Permit {
+        address owner;
+        address spender;
+        uint256 value;
+        uint256 nonce;
+        uint256 deadline;
+    }
+
+    // computes the hash of a permit
+    function getStructHash(Permit memory _permit) internal pure returns (bytes32) {
+        return keccak256(
+            abi.encode(PERMIT_TYPEHASH, _permit.owner, _permit.spender, _permit.value, _permit.nonce, _permit.deadline)
+        );
+    }
+
+    // computes the hash of the fully encoded EIP-712 message for the domain, which can be used to recover the signer
+    function getTypedDataHash(Permit memory _permit) public view returns (bytes32) {
+        return keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, getStructHash(_permit)));
+    }
+}

package/test/units/static/JBERC20/TestInitialize.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBERC20Setup} from "./JBERC20Setup.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+contract TestInitialize_Local is JBERC20Setup {
+    string _name = "Nana";
+    string _symbol = "NANA";
+
+    function setUp() public {
+        super.erc20Setup();
+    }
+
+    function test_WhenANameIsAlreadySet() external {
+        // it will revert
+
+        _erc20.initialize(_name, _symbol, _owner);
+
+        // ensure ownership transferred
+        address newOwner = Ownable(address(_erc20)).owner();
+        assertEq(newOwner, _owner);
+
+        // will fail as internal name is no longer zero length
+        vm.expectRevert();
+        _erc20.initialize(_name, _symbol, _owner);
+    }
+
+    function test_WhenName_EQNothing() external {
+        // it will revert
+
+        // will fail as internal name is no longer than zero length
+        vm.expectRevert();
+        _erc20.initialize("", _symbol, _owner);
+    }
+
+    function test_WhenNameIsValidAndNotAlreadySet() external {
+        // it will set the name and symbol and transfer ownership
+
+        _erc20.initialize(_name, _symbol, _owner);
+
+        // ensure ownership transferred
+        address newOwner = Ownable(address(_erc20)).owner();
+        assertEq(newOwner, _owner);
+
+        // name is set
+        string memory _setName = IERC20Metadata(address(_erc20)).name();
+        string memory _setSymbol = IERC20Metadata(address(_erc20)).symbol();
+
+        assertEq(_setName, _name);
+        assertEq(_setSymbol, _symbol);
+    }
+}

package/test/units/static/JBERC20/TestName.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBERC20Setup} from "./JBERC20Setup.sol";
+
+contract TestName_Local is JBERC20Setup {
+    IERC20Metadata _token;
+
+    function setUp() public {
+        super.erc20Setup();
+
+        _token = IERC20Metadata(address(_erc20));
+    }
+
+    function test_WhenANameIsSet() external {
+        // it will return the name
+        _erc20.initialize("NANAPUS", "NANA", _owner);
+
+        string memory _setName = _token.name();
+        assertEq(_setName, "NANAPUS");
+    }
+
+    function test_WhenANameIsNotSet() external view {
+        // it will return an empty string
+
+        string memory _storedName = _token.name();
+        assertEq(_storedName, "");
+    }
+}

package/test/units/static/JBERC20/TestNonces.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBERC20Setup} from "./JBERC20Setup.sol";
+import {SigUtils} from "./SigUtils.sol";
+
+contract TestNonces_Local is JBERC20Setup {
+    IERC20Permit _token;
+    SigUtils sigUtils;
+
+    bytes32 private immutable _hashedName = keccak256(bytes("JBToken"));
+    bytes32 private immutable _hashedVersion = keccak256(bytes("1"));
+
+    bytes32 _domain;
+
+    bytes32 private constant TYPE_HASH =
+        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
+
+    function setUp() public {
+        super.erc20Setup();
+
+        _token = IERC20Permit(address(_erc20));
+        _domain = keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(_token)));
+        sigUtils = new SigUtils(_domain);
+    }
+
+    function test_WhenAUserHasNotCalledPermit() external view {
+        // it will return zero
+
+        uint256 _nonce = _token.nonces(_owner);
+
+        assertEq(_nonce, 0);
+    }
+
+    function test_WhenAUserHasCalledPermit() external {
+        // it will return a nonce GT zero
+
+        (address holder, uint256 holderPk) = makeAddrAndKey("hodler");
+
+        SigUtils.Permit memory permit = SigUtils.Permit({
+            owner: holder,
+            spender: address(this),
+            value: 1,
+            nonce: _token.nonces(holder),
+            deadline: block.timestamp + 1 days
+        });
+
+        bytes32 digest = sigUtils.getTypedDataHash(permit);
+
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(holderPk, digest);
+
+        vm.prank(holder);
+        _token.permit(holder, address(this), 1, block.timestamp + 1 days, v, r, s);
+
+        uint256 _nonce = _token.nonces(holder);
+        assertEq(_nonce, 1);
+    }
+}

package/test/units/static/JBERC20/TestSymbol.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBERC20Setup} from "./JBERC20Setup.sol";
+
+contract TestSymbol_Local is JBERC20Setup {
+    IERC20Metadata _token;
+
+    function setUp() public {
+        super.erc20Setup();
+
+        _token = IERC20Metadata(address(_erc20));
+    }
+
+    function test_WhenASymbolIsSet() external {
+        // it will return a non-empty string
+
+        _erc20.initialize("NANAPUS", "NANA", _owner);
+
+        string memory _setSymbol = _token.symbol();
+        assertEq(_setSymbol, "NANA");
+    }
+
+    function test_WhenASymbolIsNotSet() external view {
+        // it will return an empty string
+
+        string memory _setSymbol = _token.symbol();
+        assertEq(_setSymbol, "");
+    }
+}

package/test/units/static/JBFeelessAdresses/JBFeelessSetup.sol

@@ -0,0 +1,20 @@
+// 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 JBFeelessSetup is JBTest {
+    address _owner = makeAddr("owner");
+
+    // Target Contract
+    IJBFeelessAddresses public _feelessAddresses;
+
+    function feelessAddressesSetup() public virtual {
+        // Instantiate the contract being tested
+        _feelessAddresses = new JBFeelessAddresses(_owner);
+    }
+}

package/test/units/static/JBFeelessAdresses/TestInterfaces.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBFeelessSetup} from "./JBFeelessSetup.sol";
+
+contract TestSupportsInterface_Local is JBFeelessSetup {
+    function setUp() public {
+        super.feelessAddressesSetup();
+    }
+
+    function test_WhenItSupportsEitherIJBFeelessAddressesOrIERC165() external view {
+        // it should return true
+        bool result1 = IERC165(address(_feelessAddresses)).supportsInterface(type(IJBFeelessAddresses).interfaceId);
+        assertEq(result1, true);
+
+        bool result2 = IERC165(address(_feelessAddresses)).supportsInterface(type(IERC165).interfaceId);
+        assertEq(result2, true);
+    }
+
+    function test_WhenAskedIfSupportsNonIJBFeelessAddressesOrIERC165() external view {
+        // it should return false
+        bool result1 = IERC165(address(_feelessAddresses)).supportsInterface(0x12345678);
+        assertEq(result1, false);
+
+        bool result2 = IERC165(address(_feelessAddresses)).supportsInterface(0x12345679);
+        assertEq(result2, false);
+    }
+}

package/test/units/static/JBFeelessAdresses/TestSetFeelessAddress.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBFeelessSetup} from "./JBFeelessSetup.sol";
+
+contract TestSetFeelessAddress_Local is JBFeelessSetup {
+    address _feeLess = makeAddr("something");
+
+    function setUp() public {
+        super.feelessAddressesSetup();
+    }
+
+    function test_WhenCallerIsOwner() external {
+        // it should set isFeeless and emit SetFeelessAddress
+        vm.expectEmit();
+        emit IJBFeelessAddresses.SetFeelessAddress(_feeLess, true, address(_owner));
+
+        vm.prank(_owner);
+        _feelessAddresses.setFeelessAddress(_feeLess, true);
+
+        bool result = _feelessAddresses.isFeeless(_feeLess);
+        assertEq(result, true);
+    }
+
+    function test_RevertIf_RevertWhen_CallerIsNotOwner() external {
+        address _multisig = makeAddr("multisig");
+        vm.prank(_multisig);
+        // it should revert  0x7FA9385bE102ac3EAc297483Dd6233D62b3e1496
+        bytes4 selector = bytes4(keccak256("OwnableUnauthorizedAccount(address)"));
+        bytes memory expectedError = abi.encodeWithSelector(selector, _multisig);
+        vm.expectRevert(expectedError);
+        _feelessAddresses.setFeelessAddress(_feeLess, true);
+    }
+}

package/test/units/static/JBFees/TestFeesFuzz.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBFees} from "../../../../src/libraries/JBFees.sol";
+
+/// @notice Fuzz tests for the JBFees library.
+contract TestFeesFuzz_Local is JBTest {
+    function setUp() external {}
+
+    /// @notice feeAmountFrom with feePercent=0 returns 0.
+    function testFuzz_feeAmountFrom_zeroPercent(uint256 amount) external pure {
+        amount = bound(amount, 0, type(uint128).max);
+        uint256 fee = JBFees.feeAmountFrom(amount, 0);
+        assertEq(fee, 0, "fee with 0% should be 0");
+    }
+
+    /// @notice feeAmountFrom with amount=0 returns 0.
+    function testFuzz_feeAmountFrom_zeroAmount(uint256 feePercent) external pure {
+        feePercent = bound(feePercent, 0, JBConstants.MAX_FEE);
+        uint256 fee = JBFees.feeAmountFrom(0, feePercent);
+        assertEq(fee, 0, "fee on 0 amount should be 0");
+    }
+
+    /// @notice fee + remainder == amount (conservation).
+    /// @dev feeAmountFrom(amount, percent) + (amount - feeAmountFrom(amount, percent)) == amount
+    function testFuzz_feeAmountFrom_conservation(uint256 amount, uint256 feePercent) external pure {
+        amount = bound(amount, 0, type(uint128).max);
+        feePercent = bound(feePercent, 0, JBConstants.MAX_FEE);
+
+        uint256 fee = JBFees.feeAmountFrom(amount, feePercent);
+        uint256 remainder = amount - fee;
+
+        assertEq(fee + remainder, amount, "fee + remainder must equal amount");
+        assertLe(fee, amount, "fee must not exceed amount");
+    }
+
+    /// @notice fee is monotonically increasing with amount (for fixed percent).
+    function testFuzz_feeAmountFrom_monotonic(uint256 amount1, uint256 amount2, uint256 feePercent) external pure {
+        amount1 = bound(amount1, 0, type(uint64).max);
+        amount2 = bound(amount2, amount1, type(uint64).max);
+        feePercent = bound(feePercent, 0, JBConstants.MAX_FEE);
+
+        uint256 fee1 = JBFees.feeAmountFrom(amount1, feePercent);
+        uint256 fee2 = JBFees.feeAmountFrom(amount2, feePercent);
+
+        assertLe(fee1, fee2, "fee should be monotonically increasing with amount");
+    }
+
+    /// @notice feeAmountFrom and feeAmountResultingIn are directionally consistent.
+    /// @dev feeAmountResultingIn(afterFee, percent) >= fee from feeAmountFrom.
+    ///      The reverse operation should always produce a fee that covers the forward fee.
+    function testFuzz_feeSymmetry(uint256 amount, uint256 feePercent) external pure {
+        amount = bound(amount, 1, type(uint64).max);
+        feePercent = bound(feePercent, 1, JBConstants.MAX_FEE - 1); // Avoid 0% and 100%
+
+        // Forward: calculate fee from amount
+        uint256 fee = JBFees.feeAmountFrom(amount, feePercent);
+        uint256 afterFee = amount - fee;
+
+        // Reverse: from afterFee, what fee would produce afterFee as the result?
+        uint256 reverseFee = JBFees.feeAmountResultingIn(afterFee, feePercent);
+
+        // The reverse fee should always be >= the forward fee (it rounds up to ensure
+        // the total with fee >= the original amount).
+        assertGe(reverseFee, fee, "reverse fee should be >= forward fee");
+
+        // And the total should be >= the original amount (reverse is conservative)
+        assertGe(reverseFee + afterFee, amount, "reverse fee + afterFee should be >= amount");
+    }
+
+    /// @notice feeAmountFrom with MAX_FEE returns the full amount.
+    function testFuzz_feeAmountFrom_maxPercent(uint256 amount) external pure {
+        amount = bound(amount, 0, type(uint128).max);
+        uint256 fee = JBFees.feeAmountFrom(amount, JBConstants.MAX_FEE);
+        assertEq(fee, amount, "fee at MAX_FEE should equal amount");
+    }
+}

package/test/units/static/JBFixedPointNumber/TestAdjustDecimals.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBFixedPointNumber} from "../../../../src/libraries/JBFixedPointNumber.sol";
+
+contract TestAdjustDecimals_Local is JBTest {
+    function setUp() external {}
+
+    function testWhenTargetEqDecimals() external pure {
+        // it will return the value parameter provided
+
+        uint256 returned = JBFixedPointNumber.adjustDecimals(1e18, 6, 6);
+        assertEq(returned, 1e18);
+    }
+}

package/test/units/static/JBFixedPointNumber/TestAdjustDecimalsFuzz.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBFixedPointNumber} from "../../../../src/libraries/JBFixedPointNumber.sol";
+
+/// @notice Fuzz tests for JBFixedPointNumber.adjustDecimals.
+contract TestAdjustDecimalsFuzz_Local is JBTest {
+    function setUp() external {}
+
+    /// @notice Same decimals returns the value unchanged.
+    function testFuzz_sameDecimals(uint256 value, uint8 decimals) external pure {
+        decimals = uint8(bound(uint256(decimals), 0, 36));
+        uint256 result = JBFixedPointNumber.adjustDecimals(value, decimals, decimals);
+        assertEq(result, value, "same decimals should return value unchanged");
+    }
+
+    /// @notice Scale up then down round-trip preserves value (modulo rounding loss).
+    function testFuzz_roundTrip_upThenDown(uint256 value, uint8 fromDecimals, uint8 toDecimals) external pure {
+        fromDecimals = uint8(bound(uint256(fromDecimals), 0, 18));
+        toDecimals = uint8(bound(uint256(toDecimals), fromDecimals, 36));
+
+        // Avoid overflow: value * 10^(toDecimals - fromDecimals) must fit in uint256
+        uint256 scaleFactor = 10 ** (toDecimals - fromDecimals);
+        if (scaleFactor > 0 && value > type(uint256).max / scaleFactor) return;
+
+        uint256 scaled = JBFixedPointNumber.adjustDecimals(value, fromDecimals, toDecimals);
+        uint256 restored = JBFixedPointNumber.adjustDecimals(scaled, toDecimals, fromDecimals);
+
+        assertEq(restored, value, "round trip (up then down) should restore original value");
+    }
+
+    /// @notice Scale down then up loses precision but never exceeds original.
+    function testFuzz_roundTrip_downThenUp(uint256 value, uint8 fromDecimals, uint8 toDecimals) external pure {
+        fromDecimals = uint8(bound(uint256(fromDecimals), 0, 36));
+        toDecimals = uint8(bound(uint256(toDecimals), 0, fromDecimals));
+
+        uint256 scaled = JBFixedPointNumber.adjustDecimals(value, fromDecimals, toDecimals);
+
+        // Scale back up
+        uint256 scaleFactor = 10 ** (fromDecimals - toDecimals);
+        if (scaleFactor > 0 && scaled > type(uint256).max / scaleFactor) return;
+
+        uint256 restored = JBFixedPointNumber.adjustDecimals(scaled, toDecimals, fromDecimals);
+
+        assertLe(restored, value, "round trip (down then up) should not exceed original");
+    }
+
+    /// @notice Scaling up increases value when decimals differ.
+    function testFuzz_scaleUp_increases(uint256 value, uint8 fromDecimals, uint8 toDecimals) external pure {
+        value = bound(value, 1, 1e36);
+        fromDecimals = uint8(bound(uint256(fromDecimals), 0, 18));
+        toDecimals = uint8(bound(uint256(toDecimals), fromDecimals + 1, 36));
+
+        uint256 result = JBFixedPointNumber.adjustDecimals(value, fromDecimals, toDecimals);
+        assertGt(result, value, "scaling up with more decimals should increase value");
+    }
+
+    /// @notice Scaling down returns zero for small values.
+    function testFuzz_scaleDown_smallValue(uint8 fromDecimals, uint8 toDecimals) external pure {
+        fromDecimals = uint8(bound(uint256(fromDecimals), 1, 36));
+        toDecimals = uint8(bound(uint256(toDecimals), 0, fromDecimals - 1));
+
+        uint256 scaleFactor = 10 ** (fromDecimals - toDecimals);
+        // Value smaller than the scale factor should round to 0
+        uint256 value = scaleFactor - 1;
+
+        uint256 result = JBFixedPointNumber.adjustDecimals(value, fromDecimals, toDecimals);
+        assertEq(result, 0, "value below scale factor should round to 0");
+    }
+}

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

@@ -0,0 +1,21 @@
+// 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 JBFundAccessSetup is JBTest {
+    // Target Contract
+    IJBFundAccessLimits public _fundAccess;
+
+    // Mocks
+    IJBDirectory public directory = IJBDirectory(makeAddr("directory"));
+
+    function fundAccessSetup() public virtual {
+        // Instantiate the contract being tested
+        _fundAccess = new JBFundAccessLimits(directory);
+    }
+}

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

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+
+/// @notice Edge case tests for JBFundAccessLimits append behavior and packing.
+/// The key finding is that setFundAccessLimitsFor uses .push() (append), not replace.
+/// If called twice for the same rulesetId, limits accumulate rather than being replaced.
+contract TestFundAccessLimitsEdge_Local is JBTest {
+    IJBDirectory public directory = IJBDirectory(makeAddr("directory"));
+    JBFundAccessLimits public limits;
+
+    uint256 constant PROJECT_ID = 1;
+    uint256 constant RULESET_ID = 100;
+    address constant TERMINAL = address(0xBEEF);
+    address constant TOKEN = address(0xCAFE);
+
+    function setUp() public {
+        limits = new JBFundAccessLimits(directory);
+
+        // Mock controllerOf to return this contract (so we can call setFundAccessLimitsFor).
+        vm.mockCall(
+            address(directory), abi.encodeCall(IJBDirectory.controllerOf, (PROJECT_ID)), abi.encode(address(this))
+        );
+    }
+
+    // ───────────────────── Append-not-replace bug
+    // ─────────────────────
+
+    /// @notice BUG: Calling setFundAccessLimitsFor twice accumulates limits instead of replacing.
+    /// If a controller ever calls this twice for the same rulesetId (e.g., custom controller,
+    /// reentrancy, or migration bug), limits double.
+    function test_doubleSetting_accumulatesLimits() external {
+        JBCurrencyAmount[] memory payoutLimits = new JBCurrencyAmount[](1);
+        payoutLimits[0] = JBCurrencyAmount({amount: 1000, currency: 1});
+
+        JBFundAccessLimitGroup[] memory groups = new JBFundAccessLimitGroup[](1);
+        groups[0] = JBFundAccessLimitGroup({
+            terminal: TERMINAL, token: TOKEN, payoutLimits: payoutLimits, surplusAllowances: new JBCurrencyAmount[](0)
+        });
+
+        // First call — sets limit to 1000.
+        limits.setFundAccessLimitsFor(PROJECT_ID, RULESET_ID, groups);
+
+        // Verify first limit.
+        uint256 limit1 = limits.payoutLimitOf(PROJECT_ID, RULESET_ID, TERMINAL, TOKEN, 1);
+        assertEq(limit1, 1000, "First limit should be 1000");
+
+        // Second call with SAME rulesetId — BUG: this APPENDS, not replaces.
+        limits.setFundAccessLimitsFor(PROJECT_ID, RULESET_ID, groups);
+
+        // Query all limits — should have 2 entries now (both with currency=1, amount=1000).
+        JBCurrencyAmount[] memory allLimits = limits.payoutLimitsOf(PROJECT_ID, RULESET_ID, TERMINAL, TOKEN);
+
+        // BUG CONFIRMED: Two entries instead of one.
+        assertEq(allLimits.length, 2, "BUG: Limits accumulated instead of being replaced");
+        assertEq(allLimits[0].amount, 1000, "First accumulated limit");
+        assertEq(allLimits[1].amount, 1000, "Second accumulated limit");
+
+        // The payoutLimitOf function returns the FIRST match, so it still returns 1000.
+        // But the surplus calculation iterates ALL limits, effectively doubling the payout limit.
+        uint256 limitQuery = limits.payoutLimitOf(PROJECT_ID, RULESET_ID, TERMINAL, TOKEN, 1);
+        assertEq(limitQuery, 1000, "Query returns first match only");
+    }
+
+    // ───────────────────── Zero amount skipped
+    // ─────────────────────
+
+    /// @notice Zero-amount limits are not stored (filtered by amount > 0 check).
+    function test_zeroAmount_skipped() external {
+        JBCurrencyAmount[] memory payoutLimits = new JBCurrencyAmount[](2);
+        payoutLimits[0] = JBCurrencyAmount({amount: 0, currency: 1}); // Should be skipped.
+        payoutLimits[1] = JBCurrencyAmount({amount: 500, currency: 2});
+
+        JBFundAccessLimitGroup[] memory groups = new JBFundAccessLimitGroup[](1);
+        groups[0] = JBFundAccessLimitGroup({
+            terminal: TERMINAL, token: TOKEN, payoutLimits: payoutLimits, surplusAllowances: new JBCurrencyAmount[](0)
+        });
+
+        limits.setFundAccessLimitsFor(PROJECT_ID, RULESET_ID, groups);
+
+        // Only the non-zero limit should be stored.
+        JBCurrencyAmount[] memory allLimits = limits.payoutLimitsOf(PROJECT_ID, RULESET_ID, TERMINAL, TOKEN);
+        assertEq(allLimits.length, 1, "Zero-amount limit should not be stored");
+        assertEq(allLimits[0].amount, 500, "Only non-zero limit stored");
+        assertEq(allLimits[0].currency, 2, "Correct currency stored");
+    }
+
+    // ───────────────────── Currency ordering validation
+    // ─────────────────────
+
+    /// @notice Duplicate currencies in payout limits should revert.
+    function test_currencyOrdering_rejectsEqual() external {
+        JBCurrencyAmount[] memory payoutLimits = new JBCurrencyAmount[](2);
+        payoutLimits[0] = JBCurrencyAmount({amount: 100, currency: 1});
+        payoutLimits[1] = JBCurrencyAmount({amount: 200, currency: 1}); // Same currency!
+
+        JBFundAccessLimitGroup[] memory groups = new JBFundAccessLimitGroup[](1);
+        groups[0] = JBFundAccessLimitGroup({
+            terminal: TERMINAL, token: TOKEN, payoutLimits: payoutLimits, surplusAllowances: new JBCurrencyAmount[](0)
+        });
+
+        vm.expectRevert(JBFundAccessLimits.JBFundAccessLimits_InvalidPayoutLimitCurrencyOrdering.selector);
+        limits.setFundAccessLimitsFor(PROJECT_ID, RULESET_ID, groups);
+    }
+
+    /// @notice Descending currency order should revert.
+    function test_currencyOrdering_rejectsDescending() external {
+        JBCurrencyAmount[] memory payoutLimits = new JBCurrencyAmount[](2);
+        payoutLimits[0] = JBCurrencyAmount({amount: 100, currency: 2});
+        payoutLimits[1] = JBCurrencyAmount({amount: 200, currency: 1}); // Descending!
+
+        JBFundAccessLimitGroup[] memory groups = new JBFundAccessLimitGroup[](1);
+        groups[0] = JBFundAccessLimitGroup({
+            terminal: TERMINAL, token: TOKEN, payoutLimits: payoutLimits, surplusAllowances: new JBCurrencyAmount[](0)
+        });
+
+        vm.expectRevert(JBFundAccessLimits.JBFundAccessLimits_InvalidPayoutLimitCurrencyOrdering.selector);
+        limits.setFundAccessLimitsFor(PROJECT_ID, RULESET_ID, groups);
+    }
+
+    // ───────────────────── Packing round-trip
+    // ─────────────────────
+
+    /// @notice Fuzz: packed amount + currency unpack correctly for all inputs.
+    function testFuzz_packingRoundTrip(uint224 amount, uint32 currency) external {
+        // Skip zero amounts (they're filtered out).
+        vm.assume(amount > 0);
+        // Skip currency 0 since ordering requires > 0 for the first element.
+        vm.assume(currency > 0);
+
+        JBCurrencyAmount[] memory payoutLimits = new JBCurrencyAmount[](1);
+        payoutLimits[0] = JBCurrencyAmount({amount: amount, currency: currency});
+
+        JBFundAccessLimitGroup[] memory groups = new JBFundAccessLimitGroup[](1);
+        groups[0] = JBFundAccessLimitGroup({
+            terminal: TERMINAL, token: TOKEN, payoutLimits: payoutLimits, surplusAllowances: new JBCurrencyAmount[](0)
+        });
+
+        // Use a unique rulesetId for each fuzz run to avoid accumulation bug.
+        uint256 rulesetId = uint256(keccak256(abi.encode(amount, currency)));
+        limits.setFundAccessLimitsFor(PROJECT_ID, rulesetId, groups);
+
+        // Verify round-trip.
+        JBCurrencyAmount[] memory result = limits.payoutLimitsOf(PROJECT_ID, rulesetId, TERMINAL, TOKEN);
+        assertEq(result.length, 1, "Should have exactly one limit");
+        assertEq(result[0].amount, amount, "Amount should round-trip correctly");
+        assertEq(result[0].currency, currency, "Currency should round-trip correctly");
+    }
+
+    // ───────────────────── Query nonexistent returns zero
+    // ─────────────────────
+
+    /// @notice Querying a currency with no limit returns 0 (implicit default).
+    function test_queryNonexistentCurrency_returnsZero() external view {
+        uint256 limit = limits.payoutLimitOf(PROJECT_ID, RULESET_ID, TERMINAL, TOKEN, 999);
+        assertEq(limit, 0, "Nonexistent currency should return 0");
+    }
+}