@layerzerolabs/utils-upgradeable-evm-contracts 0.2.74

package/test/EnumerableSetPagination.t.sol

@@ -0,0 +1,445 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import { Test } from "forge-std/Test.sol";
+import { EnumerableSetPagination } from "./../contracts/libs/EnumerableSetPagination.sol";
+
+contract AddressPaginationHarness {
+    using EnumerableSet for EnumerableSet.AddressSet;
+    using EnumerableSetPagination for EnumerableSet.AddressSet;
+
+    EnumerableSet.AddressSet set;
+
+    function add(address _addr) external {
+        set.add(_addr);
+    }
+    function remove(address _addr) external {
+        set.remove(_addr);
+    }
+    function length() external view returns (uint256) {
+        return set.length();
+    }
+    function paginate(uint256 _offset, uint256 _limit) external view returns (address[] memory) {
+        return set.paginate(_offset, _limit);
+    }
+}
+
+contract UintPaginationHarness {
+    using EnumerableSet for EnumerableSet.UintSet;
+    using EnumerableSetPagination for EnumerableSet.UintSet;
+
+    EnumerableSet.UintSet set;
+
+    function add(uint256 _val) external {
+        set.add(_val);
+    }
+    function remove(uint256 _val) external {
+        set.remove(_val);
+    }
+    function length() external view returns (uint256) {
+        return set.length();
+    }
+    function paginate(uint256 _offset, uint256 _limit) external view returns (uint256[] memory) {
+        return set.paginate(_offset, _limit);
+    }
+}
+
+contract EnumerableSetPaginationTest is Test {
+    using EnumerableSet for EnumerableSet.AddressSet;
+    using EnumerableSet for EnumerableSet.UintSet;
+    using EnumerableSetPagination for EnumerableSet.AddressSet;
+    using EnumerableSetPagination for EnumerableSet.UintSet;
+
+    AddressPaginationHarness addrHarness;
+    UintPaginationHarness uintHarness;
+
+    EnumerableSet.AddressSet addrSet;
+    EnumerableSet.UintSet uintSet;
+
+    uint256 constant SET_SIZE = 1_000;
+
+    function setUp() public {
+        addrHarness = new AddressPaginationHarness();
+        uintHarness = new UintPaginationHarness();
+
+        for (uint256 i = 1; i <= SET_SIZE; i++) {
+            addrHarness.add(address(uint160(i)));
+            addrSet.add(address(uint160(i)));
+            uintHarness.add(i);
+            uintSet.add(i);
+        }
+    }
+
+    // ============ AddressSet — Empty / Single ============
+
+    function test_address_paginate_EmptySet() public {
+        AddressPaginationHarness empty = new AddressPaginationHarness();
+        assertEq(empty.paginate(0, 10).length, 0);
+    }
+
+    function test_address_paginate_SingleElement() public {
+        AddressPaginationHarness single = new AddressPaginationHarness();
+        single.add(address(0xBEEF));
+        address[] memory result = single.paginate(0, 100);
+        assertEq(result.length, 1);
+        assertEq(result[0], address(0xBEEF));
+    }
+
+    // ============ AddressSet — Offset ============
+
+    function test_address_paginate_OffsetZero() public {
+        address[] memory result = addrHarness.paginate(0, 10);
+        assertEq(result.length, 10);
+        for (uint256 i = 0; i < 10; i++) {
+            assertEq(result[i], address(uint160(i + 1)));
+        }
+    }
+
+    function test_address_paginate_MiddleOffset() public {
+        address[] memory result = addrHarness.paginate(500, 10);
+        assertEq(result.length, 10);
+        for (uint256 i = 0; i < 10; i++) {
+            assertEq(result[i], address(uint160(501 + i)));
+        }
+    }
+
+    function test_address_paginate_OffsetAtEnd() public {
+        address[] memory result = addrHarness.paginate(SET_SIZE - 1, 100);
+        assertEq(result.length, 1);
+        assertEq(result[0], address(uint160(SET_SIZE)));
+    }
+
+    function test_address_paginate_OffsetBeyondEnd() public {
+        assertEq(addrHarness.paginate(SET_SIZE, 10).length, 0);
+        assertEq(addrHarness.paginate(SET_SIZE + 1000, 10).length, 0);
+    }
+
+    // ============ AddressSet — Limit ============
+
+    function test_address_paginate_LimitZero() public {
+        assertEq(addrHarness.paginate(0, 0).length, 0);
+    }
+
+    function test_address_paginate_LimitOne() public {
+        address[] memory result = addrHarness.paginate(0, 1);
+        assertEq(result.length, 1);
+        assertEq(result[0], address(uint160(1)));
+    }
+
+    function test_address_paginate_LimitExceedsRemaining() public {
+        address[] memory result = addrHarness.paginate(SET_SIZE - 5, 100);
+        assertEq(result.length, 5);
+    }
+
+    function test_address_paginate_LimitExceedsTotal() public {
+        assertEq(addrHarness.paginate(0, SET_SIZE + 50).length, SET_SIZE);
+    }
+
+    function test_address_paginate_MaxUint256Limit() public {
+        assertEq(addrHarness.paginate(0, type(uint256).max).length, SET_SIZE);
+    }
+
+    // ============ AddressSet — Multi-Page ============
+
+    function test_address_paginate_SequentialPagesCompleteSet() public {
+        uint256 pageSize = 137;
+        uint256 collected;
+
+        for (uint256 offset = 0; offset < SET_SIZE; offset += pageSize) {
+            address[] memory page = addrHarness.paginate(offset, pageSize);
+            collected += page.length;
+
+            for (uint256 i = 0; i < page.length; i++) {
+                assertEq(page[i], address(uint160(offset + i + 1)));
+            }
+        }
+
+        assertEq(collected, SET_SIZE);
+    }
+
+    // ============ AddressSet — Dynamic (add/remove) ============
+
+    function test_address_paginate_AfterRemovingElements() public {
+        AddressPaginationHarness h = new AddressPaginationHarness();
+        for (uint256 i = 1; i <= 20; i++) h.add(address(uint160(i)));
+
+        h.remove(address(uint160(5)));
+        h.remove(address(uint160(10)));
+        h.remove(address(uint160(15)));
+
+        address[] memory result = h.paginate(0, 100);
+        assertEq(result.length, 17);
+
+        for (uint256 i = 0; i < result.length; i++) {
+            assertTrue(result[i] != address(uint160(5)));
+            assertTrue(result[i] != address(uint160(10)));
+            assertTrue(result[i] != address(uint160(15)));
+        }
+    }
+
+    // ============ AddressSet — Fuzz ============
+
+    function test_address_paginate_Fuzz(uint256 _offset, uint256 _limit) public view {
+        _offset = bound(_offset, 0, SET_SIZE * 2);
+        _limit = bound(_limit, 0, SET_SIZE * 2);
+
+        address[] memory result = addrSet.paginate(_offset, _limit);
+
+        if (_offset >= SET_SIZE) {
+            assertEq(result.length, 0);
+        } else {
+            uint256 expected = _offset + _limit > SET_SIZE ? SET_SIZE - _offset : _limit;
+            assertEq(result.length, expected);
+            for (uint256 i = 0; i < result.length; i++) {
+                assertEq(result[i], address(uint160(_offset + i + 1)));
+            }
+        }
+    }
+
+    function test_address_paginate_VaryingSize_Fuzz(uint8 _size, uint256 _offset, uint256 _limit) public {
+        EnumerableSet.AddressSet storage s = addrSet;
+        while (s.length() > 0) s.remove(s.at(0));
+
+        uint256 size = uint256(_size);
+        _offset = bound(_offset, 0, size + 50);
+        _limit = bound(_limit, 0, 300);
+
+        for (uint256 i = 0; i < size; i++) s.add(address(uint160(i + 1000)));
+
+        address[] memory result = s.paginate(_offset, _limit);
+
+        if (size == 0 || _offset >= size) {
+            assertEq(result.length, 0);
+        } else {
+            uint256 remaining = size - _offset;
+            assertEq(result.length, remaining < _limit ? remaining : _limit);
+        }
+    }
+
+    // ============ AddressSet — Properties ============
+
+    function test_address_property_ReturnedLengthNeverExceedsLimit() public view {
+        for (uint256 limit = 1; limit <= 50; limit++) {
+            for (uint256 offset = 0; offset < SET_SIZE; offset += 2000) {
+                assertLe(addrSet.paginate(offset, limit).length, limit);
+            }
+        }
+    }
+
+    function test_address_property_ConsecutivePagesNoOverlap() public view {
+        uint256 pageSize = 1337;
+        for (uint256 offset = 0; offset + pageSize < SET_SIZE; offset += pageSize) {
+            address[] memory p1 = addrSet.paginate(offset, pageSize);
+            address[] memory p2 = addrSet.paginate(offset + pageSize, pageSize);
+            if (p1.length > 0 && p2.length > 0) {
+                assertTrue(p1[p1.length - 1] != p2[0]);
+            }
+        }
+    }
+
+    // ============ UintSet — Empty / Single ============
+
+    function test_uint_paginate_EmptySet() public {
+        UintPaginationHarness empty = new UintPaginationHarness();
+        assertEq(empty.paginate(0, 10).length, 0);
+    }
+
+    function test_uint_paginate_SingleElement() public {
+        UintPaginationHarness single = new UintPaginationHarness();
+        single.add(42);
+        uint256[] memory result = single.paginate(0, 100);
+        assertEq(result.length, 1);
+        assertEq(result[0], 42);
+    }
+
+    // ============ UintSet — Offset ============
+
+    function test_uint_paginate_OffsetZero() public {
+        uint256[] memory result = uintHarness.paginate(0, 10);
+        assertEq(result.length, 10);
+        for (uint256 i = 0; i < 10; i++) {
+            assertEq(result[i], i + 1);
+        }
+    }
+
+    function test_uint_paginate_MiddleOffset() public {
+        uint256[] memory result = uintHarness.paginate(500, 10);
+        assertEq(result.length, 10);
+        for (uint256 i = 0; i < 10; i++) {
+            assertEq(result[i], 501 + i);
+        }
+    }
+
+    function test_uint_paginate_OffsetAtEnd() public {
+        uint256[] memory result = uintHarness.paginate(SET_SIZE - 1, 100);
+        assertEq(result.length, 1);
+        assertEq(result[0], SET_SIZE);
+    }
+
+    function test_uint_paginate_OffsetBeyondEnd() public {
+        assertEq(uintHarness.paginate(SET_SIZE, 10).length, 0);
+        assertEq(uintHarness.paginate(SET_SIZE + 1000, 10).length, 0);
+    }
+
+    // ============ UintSet — Limit ============
+
+    function test_uint_paginate_LimitZero() public {
+        assertEq(uintHarness.paginate(0, 0).length, 0);
+    }
+
+    function test_uint_paginate_LimitOne() public {
+        uint256[] memory result = uintHarness.paginate(0, 1);
+        assertEq(result.length, 1);
+        assertEq(result[0], 1);
+    }
+
+    function test_uint_paginate_LimitExceedsRemaining() public {
+        uint256[] memory result = uintHarness.paginate(SET_SIZE - 5, 100);
+        assertEq(result.length, 5);
+    }
+
+    function test_uint_paginate_LimitExceedsTotal() public {
+        assertEq(uintHarness.paginate(0, SET_SIZE + 50).length, SET_SIZE);
+    }
+
+    function test_uint_paginate_MaxUint256Limit() public {
+        assertEq(uintHarness.paginate(0, type(uint256).max).length, SET_SIZE);
+    }
+
+    // ============ UintSet — Multi-Page ============
+
+    function test_uint_paginate_SequentialPagesCompleteSet() public {
+        uint256 pageSize = 137;
+        uint256 collected;
+
+        for (uint256 offset = 0; offset < SET_SIZE; offset += pageSize) {
+            uint256[] memory page = uintHarness.paginate(offset, pageSize);
+            collected += page.length;
+
+            for (uint256 i = 0; i < page.length; i++) {
+                assertEq(page[i], offset + i + 1);
+            }
+        }
+
+        assertEq(collected, SET_SIZE);
+    }
+
+    // ============ UintSet — Dynamic (add/remove) ============
+
+    function test_uint_paginate_AfterRemovingElements() public {
+        UintPaginationHarness h = new UintPaginationHarness();
+        for (uint256 i = 1; i <= 20; i++) h.add(i);
+
+        h.remove(5);
+        h.remove(10);
+        h.remove(15);
+
+        uint256[] memory result = h.paginate(0, 100);
+        assertEq(result.length, 17);
+
+        for (uint256 i = 0; i < result.length; i++) {
+            assertTrue(result[i] != 5);
+            assertTrue(result[i] != 10);
+            assertTrue(result[i] != 15);
+        }
+    }
+
+    // ============ UintSet — Fuzz ============
+
+    function test_uint_paginate_Fuzz(uint256 _offset, uint256 _limit) public view {
+        _offset = bound(_offset, 0, SET_SIZE * 2);
+        _limit = bound(_limit, 0, SET_SIZE * 2);
+
+        uint256[] memory result = uintSet.paginate(_offset, _limit);
+
+        if (_offset >= SET_SIZE) {
+            assertEq(result.length, 0);
+        } else {
+            uint256 expected = _offset + _limit > SET_SIZE ? SET_SIZE - _offset : _limit;
+            assertEq(result.length, expected);
+            for (uint256 i = 0; i < result.length; i++) {
+                assertEq(result[i], _offset + i + 1);
+            }
+        }
+    }
+
+    function test_uint_paginate_VaryingSize_Fuzz(uint8 _size, uint256 _offset, uint256 _limit) public {
+        EnumerableSet.UintSet storage s = uintSet;
+        while (s.length() > 0) s.remove(s.at(0));
+
+        uint256 size = uint256(_size);
+        _offset = bound(_offset, 0, size + 50);
+        _limit = bound(_limit, 0, 300);
+
+        for (uint256 i = 0; i < size; i++) s.add(i + 1000);
+
+        uint256[] memory result = s.paginate(_offset, _limit);
+
+        if (size == 0 || _offset >= size) {
+            assertEq(result.length, 0);
+        } else {
+            uint256 remaining = size - _offset;
+            assertEq(result.length, remaining < _limit ? remaining : _limit);
+        }
+    }
+
+    // ============ UintSet — Properties ============
+
+    function test_uint_property_ReturnedLengthNeverExceedsLimit() public view {
+        for (uint256 limit = 1; limit <= 50; limit++) {
+            for (uint256 offset = 0; offset < SET_SIZE; offset += 2000) {
+                assertLe(uintSet.paginate(offset, limit).length, limit);
+            }
+        }
+    }
+
+    function test_uint_property_ConsecutivePagesNoOverlap() public view {
+        uint256 pageSize = 137;
+        for (uint256 offset = 0; offset + pageSize < SET_SIZE; offset += pageSize) {
+            uint256[] memory p1 = uintSet.paginate(offset, pageSize);
+            uint256[] memory p2 = uintSet.paginate(offset + pageSize, pageSize);
+            if (p1.length > 0 && p2.length > 0) {
+                assertTrue(p1[p1.length - 1] != p2[0]);
+            }
+        }
+    }
+
+    // ============ Large Set (10,000 items) ============
+
+    function test_address_paginate_LargeSet() public {
+        AddressPaginationHarness large = new AddressPaginationHarness();
+        uint256 size = 10_000;
+        for (uint256 i = 1; i <= size; i++) large.add(address(uint160(i)));
+
+        assertEq(large.length(), size);
+        assertEq(large.paginate(0, 50).length, 50);
+        assertEq(large.paginate(9990, 50).length, 10);
+        assertEq(large.paginate(size, 10).length, 0);
+
+        uint256 collected;
+        uint256 pageSize = 500;
+        for (uint256 offset = 0; offset < size; offset += pageSize) {
+            collected += large.paginate(offset, pageSize).length;
+        }
+        assertEq(collected, size);
+    }
+
+    function test_uint_paginate_LargeSet() public {
+        UintPaginationHarness large = new UintPaginationHarness();
+        uint256 size = 10_000;
+        for (uint256 i = 1; i <= size; i++) large.add(i);
+
+        assertEq(large.length(), size);
+        assertEq(large.paginate(0, 50).length, 50);
+        assertEq(large.paginate(9990, 50).length, 10);
+        assertEq(large.paginate(size, 10).length, 0);
+
+        uint256 collected;
+        uint256 pageSize = 500;
+        for (uint256 offset = 0; offset < size; offset += pageSize) {
+            collected += large.paginate(offset, pageSize).length;
+        }
+        assertEq(collected, size);
+    }
+}

package/test/FeeConfigBaseUpgradeable.t.sol

@@ -0,0 +1,232 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import { IFeeConfig } from "@layerzerolabs/utils-evm-contracts/contracts/interfaces/IFeeConfig.sol";
+import { TransparentUpgradeableProxy } from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import { Test } from "forge-std/Test.sol";
+import { FeeConfigBaseUpgradeable } from "./../contracts/fee-config/FeeConfigBaseUpgradeable.sol";
+
+interface IFeeConfigTestHelper is IFeeConfig {}
+
+contract FeeConfigBaseUpgradeableMock is FeeConfigBaseUpgradeable {
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize() public initializer {}
+
+    function setDefaultFeeBps(uint16 _feeBps) public {
+        _setDefaultFeeBps(_feeBps);
+    }
+
+    function setFeeBps(uint256 _id, uint16 _feeBps, bool _enabled) public {
+        _setFeeBps(_id, _feeBps, _enabled);
+    }
+}
+
+contract FeeConfigBaseUpgradeableTest is Test {
+    IFeeConfigTestHelper public feeConfigHelper;
+
+    uint32 constant EID_1 = 1;
+    uint32 constant EID_2 = 2;
+    uint16 constant BPS_DENOMINATOR = 10000;
+
+    function _deployFeeConfigHelper() internal virtual returns (IFeeConfigTestHelper) {
+        FeeConfigBaseUpgradeableMock impl = new FeeConfigBaseUpgradeableMock();
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(
+            address(impl),
+            address(this),
+            abi.encodeWithSelector(FeeConfigBaseUpgradeableMock.initialize.selector)
+        );
+
+        return IFeeConfigTestHelper(address(proxy));
+    }
+
+    function setUp() public virtual {
+        feeConfigHelper = _deployFeeConfigHelper();
+    }
+
+    function test_setDefaultFeeBps_Fuzz(uint16 _feeBps) public {
+        if (_feeBps > BPS_DENOMINATOR) {
+            vm.expectRevert(abi.encodeWithSelector(IFeeConfig.InvalidBps.selector, _feeBps));
+            feeConfigHelper.setDefaultFeeBps(_feeBps);
+        } else {
+            vm.expectEmit(false, false, false, true);
+            emit IFeeConfig.DefaultFeeBpsSet(_feeBps);
+            feeConfigHelper.setDefaultFeeBps(_feeBps);
+            assertEq(feeConfigHelper.defaultFeeBps(), _feeBps);
+        }
+    }
+
+    function test_setDefaultFeeBps() public {
+        test_setDefaultFeeBps_Fuzz(500);
+    }
+
+    function test_setFeeBps_Fuzz(uint16 _defaultFeeBps, uint32 _dstEid, uint16 _feeBps, bool _enabled) public {
+        _defaultFeeBps = uint16(bound(_defaultFeeBps, 0, BPS_DENOMINATOR));
+        feeConfigHelper.setDefaultFeeBps(_defaultFeeBps);
+        assertEq(feeConfigHelper.defaultFeeBps(), _defaultFeeBps);
+
+        if (_feeBps > BPS_DENOMINATOR) {
+            vm.expectRevert(abi.encodeWithSelector(IFeeConfig.InvalidBps.selector, _feeBps));
+            feeConfigHelper.setFeeBps(_dstEid, _feeBps, _enabled);
+        } else {
+            vm.expectEmit(false, false, false, true);
+            emit IFeeConfig.FeeBpsSet(_dstEid, _feeBps, _enabled);
+            feeConfigHelper.setFeeBps(_dstEid, _feeBps, _enabled);
+
+            IFeeConfig.FeeConfig memory config = feeConfigHelper.feeBps(_dstEid);
+            assertEq(config.feeBps, _feeBps);
+            assertEq(config.enabled, _enabled);
+
+            uint256 fee = feeConfigHelper.getFee(_dstEid, 10000);
+            uint16 expectedBps = _enabled ? _feeBps : _defaultFeeBps;
+            assertEq(fee, expectedBps);
+        }
+    }
+
+    function test_setFeeBps() public {
+        test_setFeeBps_Fuzz(500, EID_1, 200, true);
+    }
+
+    function test_getFee_Fuzz(uint16 _defaultFeeBps, uint32 _dstEid, uint240 _amount) public {
+        _defaultFeeBps = uint16(bound(_defaultFeeBps, 0, BPS_DENOMINATOR));
+        feeConfigHelper.setDefaultFeeBps(_defaultFeeBps);
+
+        uint256 expectedFee = _defaultFeeBps == 0 ? 0 : (uint256(_amount) * _defaultFeeBps) / BPS_DENOMINATOR;
+        assertEq(feeConfigHelper.getFee(_dstEid, _amount), expectedFee);
+    }
+
+    function test_setDefaultFeeBps_RevertInvalid() public {
+        vm.expectRevert(abi.encodeWithSelector(IFeeConfig.InvalidBps.selector, 10001));
+        feeConfigHelper.setDefaultFeeBps(10001);
+    }
+
+    function test_setFeeBps_RevertInvalid() public {
+        vm.expectRevert(abi.encodeWithSelector(IFeeConfig.InvalidBps.selector, 10001));
+        feeConfigHelper.setFeeBps(EID_1, 10001, true);
+    }
+
+    function test_getFee_Default() public {
+        feeConfigHelper.setDefaultFeeBps(500);
+        uint256 amount = 1000;
+        uint256 expectedFee = 50;
+        assertEq(feeConfigHelper.getFee(EID_1, amount), expectedFee);
+    }
+
+    function test_getFee_Specific() public {
+        feeConfigHelper.setDefaultFeeBps(500);
+        feeConfigHelper.setFeeBps(EID_1, 200, true);
+        uint256 amount = 1000;
+        uint256 expectedFee = 20;
+        assertEq(feeConfigHelper.getFee(EID_1, amount), expectedFee);
+    }
+
+    function test_getFee_SpecificDisabled() public {
+        feeConfigHelper.setDefaultFeeBps(500);
+        feeConfigHelper.setFeeBps(EID_1, 200, false);
+        uint256 amount = 1000;
+        uint256 expectedFee = 50;
+        assertEq(feeConfigHelper.getFee(EID_1, amount), expectedFee);
+    }
+
+    function test_getFee_BoundaryConditions() public {
+        feeConfigHelper.setDefaultFeeBps(500);
+        assertEq(feeConfigHelper.getFee(EID_1, 0), 0);
+        feeConfigHelper.setFeeBps(EID_1, 10000, true);
+        assertEq(feeConfigHelper.getFee(EID_1, 100), 100);
+        feeConfigHelper.setFeeBps(EID_1, 0, true);
+        assertEq(feeConfigHelper.getFee(EID_1, 1000), 0);
+    }
+
+    function test_getFee_Rounding() public {
+        feeConfigHelper.setDefaultFeeBps(1000);
+        assertEq(feeConfigHelper.getFee(EID_1, 15), 1);
+        assertEq(feeConfigHelper.getFee(EID_1, 9), 0);
+    }
+
+    // ============ getAmountBeforeFee Tests ============
+
+    function test_getAmountBeforeFee_ZeroBps() public view {
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, 0), 0);
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, 1000), 1000);
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, type(uint256).max), type(uint256).max);
+    }
+
+    function test_getAmountBeforeFee_MaxBps() public {
+        feeConfigHelper.setDefaultFeeBps(BPS_DENOMINATOR);
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, 0), 0);
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, 1000), 0);
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, type(uint256).max), 0);
+    }
+
+    function test_getAmountBeforeFee_Default() public {
+        feeConfigHelper.setDefaultFeeBps(500);
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, 950), 1000);
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_2, 950), 1000);
+    }
+
+    function test_getAmountBeforeFee_Specific() public {
+        feeConfigHelper.setDefaultFeeBps(500);
+        feeConfigHelper.setFeeBps(EID_1, 200, true);
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, 980), 1000);
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_2, 950), 1000);
+    }
+
+    function test_getAmountBeforeFee_SpecificDisabled() public {
+        feeConfigHelper.setDefaultFeeBps(500);
+        feeConfigHelper.setFeeBps(EID_1, 200, false);
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, 950), 1000);
+    }
+
+    function test_getAmountBeforeFee_ZeroAmount() public {
+        feeConfigHelper.setDefaultFeeBps(500);
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, 0), 0);
+    }
+
+    function test_getAmountBeforeFee_Rounding() public {
+        feeConfigHelper.setDefaultFeeBps(1000);
+
+        // (15 * 10000) / 9000 = 16, getFee(16) = 1, 16-1 = 15.
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, 15), 16);
+        // (9 * 10000) / 9000 = 10, getFee(10) = 1, 10-1 = 9.
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, 9), 10);
+        // (1 * 10000) / 9000 = 1, getFee(1) = 0, 1-0 = 1.
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, 1), 1);
+    }
+
+    function test_getAmountBeforeFee_BoundaryConditions() public {
+        // 1 bps (0.01%) — near-zero fee.
+        feeConfigHelper.setDefaultFeeBps(1);
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, 9999), 10000);
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, 1), 1);
+
+        // 9999 bps (99.99%) — near-total fee.
+        feeConfigHelper.setDefaultFeeBps(9999);
+        // (1 * 10000) / 1 = 10000, getFee(10000) = 9999, 10000-9999 = 1.
+        assertEq(feeConfigHelper.getAmountBeforeFee(EID_1, 1), 10000);
+    }
+
+    function test_getAmountBeforeFee_Fuzz(uint16 _feeBps, uint224 _amountAfterFee) public {
+        _feeBps = uint16(bound(_feeBps, 0, BPS_DENOMINATOR));
+        feeConfigHelper.setDefaultFeeBps(_feeBps);
+
+        uint256 amountBefore = feeConfigHelper.getAmountBeforeFee(EID_1, _amountAfterFee);
+
+        if (_feeBps == BPS_DENOMINATOR) {
+            assertEq(amountBefore, 0);
+        } else if (_feeBps == 0) {
+            assertEq(amountBefore, _amountAfterFee);
+        } else {
+            // Core inverse invariant: `amountBefore - getFee(amountBefore) == amountAfterFee`.
+            uint256 fee = feeConfigHelper.getFee(EID_1, amountBefore);
+            assertEq(amountBefore - fee, _amountAfterFee);
+        }
+    }
+
+    function test_storageHash() public pure {
+        bytes32 storageHash = keccak256(abi.encode(uint256(keccak256("layerzerov2.storage.feeconfig")) - 1)) &
+            ~bytes32(uint256(0xff));
+        assertEq(storageHash, 0x19c40dd5c7b9d6e4dbe259e67955cccfb75eaf6c218fbfbd413bfcd8248dd800);
+    }
+}