solidity-scale-codec 0.1.0 → 0.1.1

package/README.md

@@ -1,6 +1,6 @@
 # Solidity Scale Codec
 
-<a href="https://www.npmjs.com/~lucasgrasso" target="_blank"><img alt="NPM Version" src="https://img.shields.io/npm/v/solidity-scale-codec">
+<a href="https://www.npmjs.com/package/solidity-scale-codec" target="_blank"><img alt="NPM Version" src="https://img.shields.io/npm/v/solidity-scale-codec">
 </a>
 <a href="https://github.com/LucasGrasso/solidity-scale-codec/blob/main/LICENSE" target="_blank"><img alt="GitHub License" src="https://img.shields.io/github/license/LucasGrasso/solidity-scale-codec"></a>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solidity-scale-codec",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Solidity implementation of scale-codec.",
   "keywords": [
     "solidity",
@@ -16,7 +16,8 @@
     "url": "git+https://github.com/LucasGrasso/solidity-scale-codec.git"
   },
   "files": [
-    "src/**/*.sol"
+    "src/**/*.sol",
+    "!src/**/*.t.sol"
   ],
   "license": "Apache-2.0",
   "author": "LucasGrasso",

package/src/Scale/Compact/Compact.t.sol

@@ -1,326 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
-
-import {Compact} from "./Compact.sol";
-import {Test} from "forge-std/Test.sol";
-
-/// @dev Wrapper contract to test reverts (vm.expectRevert needs external calls)
-contract CompactWrapper {
-    function decode(
-        bytes memory data
-    ) external pure returns (uint256, uint256) {
-        return Compact.decode(data);
-    }
-
-    function decodeAt(
-        bytes memory data,
-        uint256 offset
-    ) external pure returns (uint256, uint256) {
-        return Compact.decodeAt(data, offset);
-    }
-}
-
-contract CompactTest is Test {
-    CompactWrapper wrapper;
-
-    function setUp() public {
-        wrapper = new CompactWrapper();
-    }
-
-    // ============ Single-byte mode (0-63) ============
-
-    function test_Encode_0() public pure {
-        assertEq(Compact.encode(0), hex"00");
-    }
-
-    function test_Encode_1() public pure {
-        assertEq(Compact.encode(1), hex"04");
-    }
-
-    function test_Encode_2() public pure {
-        assertEq(Compact.encode(2), hex"08");
-    }
-
-    function test_Encode_3() public pure {
-        assertEq(Compact.encode(3), hex"0c");
-    }
-
-    function test_Encode_63() public pure {
-        assertEq(Compact.encode(63), hex"fc");
-    }
-
-    // ============ Two-byte mode (64-16383) ============
-
-    function test_Encode_64() public pure {
-        assertEq(Compact.encode(64), hex"0101");
-    }
-
-    function test_Encode_65() public pure {
-        assertEq(Compact.encode(65), hex"0501");
-    }
-
-    function test_Encode_16383() public pure {
-        assertEq(Compact.encode(16383), hex"fdff");
-    }
-
-    // ============ Four-byte mode (16384-1073741823) ============
-
-    function test_Encode_16384() public pure {
-        assertEq(Compact.encode(16384), hex"02000100");
-    }
-
-    function test_Encode_1073741823() public pure {
-        assertEq(Compact.encode(1073741823), hex"feffffff");
-    }
-
-    // ============ Big-integer mode (>1073741823) ============
-
-    function test_Encode_1073741824() public pure {
-        assertEq(Compact.encode(1073741824), hex"0300000040");
-    }
-
-    function test_Encode_MaxUint32() public pure {
-        assertEq(Compact.encode(type(uint32).max), hex"03ffffffff");
-    }
-
-    function test_Encode_MaxUint64() public pure {
-        bytes memory encoded = Compact.encode(type(uint64).max);
-        assertEq(encoded[0], bytes1(0x13));
-        assertEq(encoded.length, 9);
-    }
-
-    function test_Encode_BigInt_100000000000000() public pure {
-        assertEq(Compact.encode(100000000000000), hex"0b00407a10f35a");
-    }
-
-    // ============ Decode single-byte ============
-
-    function test_Decode_0() public pure {
-        (uint256 value, uint256 bytesRead) = Compact.decode(hex"00");
-        assertEq(value, 0);
-        assertEq(bytesRead, 1);
-    }
-
-    function test_Decode_1() public pure {
-        (uint256 value, uint256 bytesRead) = Compact.decode(hex"04");
-        assertEq(value, 1);
-        assertEq(bytesRead, 1);
-    }
-
-    function test_Decode_63() public pure {
-        (uint256 value, uint256 bytesRead) = Compact.decode(hex"fc");
-        assertEq(value, 63);
-        assertEq(bytesRead, 1);
-    }
-
-    // ============ Decode two-byte ============
-
-    function test_Decode_64() public pure {
-        (uint256 value, uint256 bytesRead) = Compact.decode(hex"0101");
-        assertEq(value, 64);
-        assertEq(bytesRead, 2);
-    }
-
-    function test_Decode_65() public pure {
-        (uint256 value, uint256 bytesRead) = Compact.decode(hex"0501");
-        assertEq(value, 65);
-        assertEq(bytesRead, 2);
-    }
-
-    function test_Decode_16383() public pure {
-        (uint256 value, uint256 bytesRead) = Compact.decode(hex"fdff");
-        assertEq(value, 16383);
-        assertEq(bytesRead, 2);
-    }
-
-    // ============ Decode four-byte ============
-
-    function test_Decode_16384() public pure {
-        (uint256 value, uint256 bytesRead) = Compact.decode(hex"02000100");
-        assertEq(value, 16384);
-        assertEq(bytesRead, 4);
-    }
-
-    function test_Decode_1073741823() public pure {
-        (uint256 value, uint256 bytesRead) = Compact.decode(hex"feffffff");
-        assertEq(value, 1073741823);
-        assertEq(bytesRead, 4);
-    }
-
-    // ============ Decode big-integer ============
-
-    function test_Decode_1073741824() public pure {
-        (uint256 value, uint256 bytesRead) = Compact.decode(hex"0300000040");
-        assertEq(value, 1073741824);
-        assertEq(bytesRead, 5);
-    }
-
-    function test_Decode_MaxUint32() public pure {
-        (uint256 value, uint256 bytesRead) = Compact.decode(hex"03ffffffff");
-        assertEq(value, type(uint32).max);
-        assertEq(bytesRead, 5);
-    }
-
-    function test_Decode_BigInt_100000000000000() public pure {
-        (uint256 value, uint256 bytesRead) = Compact.decode(
-            hex"0b00407a10f35a"
-        );
-        assertEq(value, 100000000000000);
-        assertEq(bytesRead, 7);
-    }
-
-    // ============ DecodeAt with offset ============
-
-    function test_DecodeAt() public pure {
-        bytes memory data = hex"04010102000100";
-
-        (uint256 v1, uint256 r1) = Compact.decodeAt(data, 0);
-        assertEq(v1, 1);
-        assertEq(r1, 1);
-
-        (uint256 v2, uint256 r2) = Compact.decodeAt(data, 1);
-        assertEq(v2, 64);
-        assertEq(r2, 2);
-
-        (uint256 v3, uint256 r3) = Compact.decodeAt(data, 3);
-        assertEq(v3, 16384);
-        assertEq(r3, 4);
-    }
-
-    // ============ Typed encoding ============
-
-    function test_EncodeU8() public pure {
-        assertEq(Compact.encodeU8(42), hex"a8");
-        assertEq(Compact.encodeU8(255), hex"fd03");
-    }
-
-    function test_EncodeU16() public pure {
-        assertEq(Compact.encodeU16(1000), hex"a10f");
-        assertEq(Compact.encodeU16(65535), hex"feff0300");
-    }
-
-    function test_EncodeU32() public pure {
-        assertEq(Compact.encodeU32(1000000), hex"02093d00");
-    }
-
-    // ============ Typed decoding ============
-
-    function test_DecodeU8() public pure {
-        (uint8 value, uint256 bytesRead) = Compact.decodeU8(hex"a8");
-        assertEq(value, 42);
-        assertEq(bytesRead, 1);
-    }
-
-    function test_DecodeU16() public pure {
-        (uint16 value, uint256 bytesRead) = Compact.decodeU16(hex"a10f");
-        assertEq(value, 1000);
-        assertEq(bytesRead, 2);
-    }
-
-    function test_DecodeU32() public pure {
-        (uint32 value, uint256 bytesRead) = Compact.decodeU32(hex"02093d00");
-        assertEq(value, 1000000);
-        assertEq(bytesRead, 4);
-    }
-
-    // ============ encodedLength ============
-
-    function test_EncodedLength() public pure {
-        assertEq(Compact.encodedLength(0), 1);
-        assertEq(Compact.encodedLength(63), 1);
-        assertEq(Compact.encodedLength(64), 2);
-        assertEq(Compact.encodedLength(16383), 2);
-        assertEq(Compact.encodedLength(16384), 4);
-        assertEq(Compact.encodedLength(1073741823), 4);
-        assertEq(Compact.encodedLength(1073741824), 5);
-        assertEq(Compact.encodedLength(type(uint64).max), 9);
-    }
-
-    // ============ Mode checks ============
-
-    function test_IsSingleByte() public pure {
-        assertTrue(Compact.isSingleByte(0));
-        assertTrue(Compact.isSingleByte(63));
-        assertFalse(Compact.isSingleByte(64));
-    }
-
-    function test_IsTwoByte() public pure {
-        assertFalse(Compact.isTwoByte(63));
-        assertTrue(Compact.isTwoByte(64));
-        assertTrue(Compact.isTwoByte(16383));
-        assertFalse(Compact.isTwoByte(16384));
-    }
-
-    function test_IsFourByte() public pure {
-        assertFalse(Compact.isFourByte(16383));
-        assertTrue(Compact.isFourByte(16384));
-        assertTrue(Compact.isFourByte(1073741823));
-        assertFalse(Compact.isFourByte(1073741824));
-    }
-
-    function test_IsBigInt() public pure {
-        assertFalse(Compact.isBigInt(1073741823));
-        assertTrue(Compact.isBigInt(1073741824));
-        assertTrue(Compact.isBigInt(type(uint256).max));
-    }
-
-    // ============ Fuzz roundtrip ============
-
-    function testFuzz_Roundtrip(uint256 value) public pure {
-        bytes memory encoded = Compact.encode(value);
-        (uint256 decoded, ) = Compact.decode(encoded);
-        assertEq(decoded, value);
-    }
-
-    function testFuzz_RoundtripU8(uint8 value) public pure {
-        bytes memory encoded = Compact.encodeU8(value);
-        (uint8 decoded, ) = Compact.decodeU8(encoded);
-        assertEq(decoded, value);
-    }
-
-    function testFuzz_RoundtripU16(uint16 value) public pure {
-        bytes memory encoded = Compact.encodeU16(value);
-        (uint16 decoded, ) = Compact.decodeU16(encoded);
-        assertEq(decoded, value);
-    }
-
-    function testFuzz_RoundtripU32(uint32 value) public pure {
-        bytes memory encoded = Compact.encodeU32(value);
-        (uint32 decoded, ) = Compact.decodeU32(encoded);
-        assertEq(decoded, value);
-    }
-
-    function testFuzz_RoundtripU64(uint64 value) public pure {
-        bytes memory encoded = Compact.encodeU64(value);
-        (uint64 decoded, ) = Compact.decodeU64(encoded);
-        assertEq(decoded, value);
-    }
-
-    function testFuzz_RoundtripU128(uint128 value) public pure {
-        bytes memory encoded = Compact.encodeU128(value);
-        (uint128 decoded, ) = Compact.decodeU128(encoded);
-        assertEq(decoded, value);
-    }
-
-    // ============ Error cases (using wrapper for external calls) ============
-
-    function test_RevertOnEmptyData() public {
-        vm.expectRevert(Compact.InvalidCompactEncoding.selector);
-        wrapper.decode(hex"");
-    }
-
-    function test_RevertOnTruncatedTwoByte() public {
-        vm.expectRevert(Compact.InvalidCompactEncoding.selector);
-        wrapper.decode(hex"01"); // Mode 0b01 but only 1 byte
-    }
-
-    function test_RevertOnTruncatedFourByte() public {
-        vm.expectRevert(Compact.InvalidCompactEncoding.selector);
-        wrapper.decode(hex"020001"); // Mode 0b10 but only 3 bytes
-    }
-
-    function test_RevertOnTruncatedBigInt() public {
-        vm.expectRevert(Compact.InvalidCompactEncoding.selector);
-        wrapper.decode(hex"030000"); // Header says 4 bytes but only 2 provided
-    }
-}

package/src/Utils/LittleEndian/LittleEndian.t.sol

@@ -1,542 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
-
-import {LittleEndian} from "./LittleEndian.sol";
-import {Test} from "forge-std/Test.sol";
-
-contract LittleEndianTest is Test {
-    // ============ uint8 / bytes1 ============
-
-    function test_Convert8_Basic() public pure {
-        assertEq(LittleEndian.toLittleEndianU8(0xAB), bytes1(0xAB));
-    }
-
-    function test_Convert8_Zero() public pure {
-        assertEq(LittleEndian.toLittleEndianU8(0), bytes1(0));
-    }
-
-    function test_Convert8_Max() public pure {
-        assertEq(LittleEndian.toLittleEndianU8(0xFF), bytes1(0xFF));
-    }
-
-    function testFuzz_Convert8(uint8 value) public pure {
-        assertEq(uint8(LittleEndian.toLittleEndianU8(value)), value);
-    }
-
-    // ============ uint16 / bytes2 ============
-
-    function test_Convert16_Basic() public pure {
-        assertEq(LittleEndian.toLittleEndianU16(0xABCD), bytes2(0xCDAB));
-    }
-
-    function test_Convert16_Zero() public pure {
-        assertEq(LittleEndian.toLittleEndianU16(0), bytes2(0));
-    }
-
-    function test_Convert16_Max() public pure {
-        assertEq(LittleEndian.toLittleEndianU16(0xFFFF), bytes2(0xFFFF));
-    }
-
-    function testFuzz_Roundtrip16(uint16 value) public pure {
-        bytes2 le = LittleEndian.toLittleEndianU16(value);
-        uint16 reconstructed = uint16(uint8(le[0])) |
-            (uint16(uint8(le[1])) << 8);
-        assertEq(reconstructed, value);
-    }
-
-    // ============ uint32 / bytes4 ============
-
-    function test_Convert32_Basic() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianU32(0x12345678),
-            bytes4(0x78563412)
-        );
-    }
-
-    function test_Convert32_Zero() public pure {
-        assertEq(LittleEndian.toLittleEndianU32(0), bytes4(0));
-    }
-
-    function test_Convert32_Max() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianU32(0xFFFFFFFF),
-            bytes4(0xFFFFFFFF)
-        );
-    }
-
-    function testFuzz_Roundtrip32(uint32 value) public pure {
-        bytes4 le = LittleEndian.toLittleEndianU32(value);
-        uint32 reconstructed = uint32(uint8(le[0])) |
-            (uint32(uint8(le[1])) << 8) |
-            (uint32(uint8(le[2])) << 16) |
-            (uint32(uint8(le[3])) << 24);
-        assertEq(reconstructed, value);
-    }
-
-    // ============ uint64 / bytes8 ============
-
-    function test_Convert64_Basic() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianU64(0x0102030405060708),
-            bytes8(0x0807060504030201)
-        );
-    }
-
-    function test_Convert64_Zero() public pure {
-        assertEq(LittleEndian.toLittleEndianU64(0), bytes8(0));
-    }
-
-    function test_Convert64_Max() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianU64(type(uint64).max),
-            bytes8(0xFFFFFFFFFFFFFFFF)
-        );
-    }
-
-    function testFuzz_Roundtrip64(uint64 value) public pure {
-        bytes8 le = LittleEndian.toLittleEndianU64(value);
-        uint64 reconstructed;
-        for (uint256 i = 0; i < 8; i++) {
-            reconstructed |= uint64(uint8(le[i])) << (i * 8);
-        }
-        assertEq(reconstructed, value);
-    }
-
-    // ============ uint128 / bytes16 ============
-
-    function test_Convert128_Basic() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianU128(0x0102030405060708090a0b0c0d0e0f10),
-            bytes16(0x100f0e0d0c0b0a090807060504030201)
-        );
-    }
-
-    function test_Convert128_Zero() public pure {
-        assertEq(LittleEndian.toLittleEndianU128(0), bytes16(0));
-    }
-
-    function test_Convert128_Max() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianU128(type(uint128).max),
-            bytes16(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
-        );
-    }
-
-    function testFuzz_Roundtrip128(uint128 value) public pure {
-        bytes16 le = LittleEndian.toLittleEndianU128(value);
-        uint128 reconstructed;
-        for (uint256 i = 0; i < 16; i++) {
-            reconstructed |= uint128(uint8(le[i])) << (i * 8);
-        }
-        assertEq(reconstructed, value);
-    }
-
-    // ============ uint256 / bytes32 ============
-
-    function test_Convert256_Basic() public pure {
-        uint256 value = 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20;
-        assertEq(
-            LittleEndian.toLittleEndianU256(value),
-            bytes32(
-                0x201f1e1d1c1b1a191817161514131211100f0e0d0c0b0a090807060504030201
-            )
-        );
-    }
-
-    function test_Convert256_Zero() public pure {
-        assertEq(LittleEndian.toLittleEndianU256(0), bytes32(0));
-    }
-
-    function test_Convert256_Max() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianU256(type(uint256).max),
-            bytes32(type(uint256).max)
-        );
-    }
-
-    function testFuzz_Roundtrip256(uint256 value) public pure {
-        bytes32 le = LittleEndian.toLittleEndianU256(value);
-        uint256 reconstructed;
-        for (uint256 i = 0; i < 32; i++) {
-            reconstructed |= uint256(uint8(le[i])) << (i * 8);
-        }
-        assertEq(reconstructed, value);
-    }
-
-    // ============ Idempotency: f(f(x)) == x ============
-
-    function testFuzz_Idempotent16(uint16 value) public pure {
-        bytes2 le = LittleEndian.toLittleEndianU16(value);
-        bytes2 back = LittleEndian.toLittleEndianU16(uint16(le));
-        assertEq(uint16(back), value);
-    }
-
-    function testFuzz_Idempotent32(uint32 value) public pure {
-        bytes4 le = LittleEndian.toLittleEndianU32(value);
-        bytes4 back = LittleEndian.toLittleEndianU32(uint32(le));
-        assertEq(uint32(back), value);
-    }
-
-    function testFuzz_Idempotent64(uint64 value) public pure {
-        bytes8 le = LittleEndian.toLittleEndianU64(value);
-        bytes8 back = LittleEndian.toLittleEndianU64(uint64(le));
-        assertEq(uint64(back), value);
-    }
-
-    function testFuzz_Idempotent128(uint128 value) public pure {
-        bytes16 le = LittleEndian.toLittleEndianU128(value);
-        bytes16 back = LittleEndian.toLittleEndianU128(uint128(le));
-        assertEq(uint128(back), value);
-    }
-
-    function testFuzz_Idempotent256(uint256 value) public pure {
-        bytes32 le = LittleEndian.toLittleEndianU256(value);
-        bytes32 back = LittleEndian.toLittleEndianU256(uint256(le));
-        assertEq(uint256(back), value);
-    }
-
-    // ============ Signed int8 ============
-
-    function test_ConvertSigned8_Positive() public pure {
-        assertEq(LittleEndian.toLittleEndianI8(int8(1)), bytes1(0x01));
-    }
-
-    function test_ConvertSigned8_Negative() public pure {
-        assertEq(LittleEndian.toLittleEndianI8(int8(-1)), bytes1(0xff));
-    }
-
-    function test_ConvertSigned8_Min() public pure {
-        assertEq(LittleEndian.toLittleEndianI8(type(int8).min), bytes1(0x80));
-    }
-
-    function test_ConvertSigned8_Max() public pure {
-        assertEq(LittleEndian.toLittleEndianI8(type(int8).max), bytes1(0x7f));
-    }
-
-    // ============ Signed int16 ============
-
-    function test_ConvertSigned16_Positive() public pure {
-        assertEq(LittleEndian.toLittleEndianI16(int16(1)), bytes2(0x0100));
-    }
-
-    function test_ConvertSigned16_Negative() public pure {
-        assertEq(LittleEndian.toLittleEndianI16(int16(-1)), bytes2(0xffff));
-    }
-
-    function test_ConvertSigned16_Neg256() public pure {
-        assertEq(LittleEndian.toLittleEndianI16(int16(-256)), bytes2(0x00ff));
-    }
-
-    function test_ConvertSigned16_Min() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianI16(type(int16).min),
-            bytes2(0x0080)
-        );
-    }
-
-    function test_ConvertSigned16_Max() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianI16(type(int16).max),
-            bytes2(0xff7f)
-        );
-    }
-
-    // ============ Signed int32 ============
-
-    function test_ConvertSigned32_Negative() public pure {
-        assertEq(LittleEndian.toLittleEndianI32(int32(-1)), bytes4(0xffffffff));
-    }
-
-    function test_ConvertSigned32_Min() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianI32(type(int32).min),
-            bytes4(0x00000080)
-        );
-    }
-
-    function test_ConvertSigned32_Max() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianI32(type(int32).max),
-            bytes4(0xffffff7f)
-        );
-    }
-
-    // ============ Signed int64 ============
-
-    function test_ConvertSigned64_Negative() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianI64(int64(-1)),
-            bytes8(0xffffffffffffffff)
-        );
-    }
-
-    function test_ConvertSigned64_Min() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianI64(type(int64).min),
-            bytes8(0x0000000000000080)
-        );
-    }
-
-    function test_ConvertSigned64_Max() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianI64(type(int64).max),
-            bytes8(0xffffffffffffff7f)
-        );
-    }
-
-    // ============ Signed int128 ============
-
-    function test_ConvertSigned128_Negative() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianI128(int128(-1)),
-            bytes16(0xffffffffffffffffffffffffffffffff)
-        );
-    }
-
-    function test_ConvertSigned128_Min() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianI128(type(int128).min),
-            bytes16(0x00000000000000000000000000000080)
-        );
-    }
-
-    // ============ Signed int256 ============
-
-    function test_ConvertSigned256_Negative() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianI256(int256(-1)),
-            bytes32(type(uint256).max)
-        );
-    }
-
-    function test_ConvertSigned256_Min() public pure {
-        assertEq(
-            LittleEndian.toLittleEndianI256(type(int256).min),
-            bytes32(
-                0x0000000000000000000000000000000000000000000000000000000000000080
-            )
-        );
-    }
-
-    // ============ Fuzz signed ============
-
-    function testFuzz_RoundtripSigned16(int16 value) public pure {
-        bytes2 le = LittleEndian.toLittleEndianI16(value);
-        int16 reconstructed = int16(
-            uint16(uint8(le[0])) | (uint16(uint8(le[1])) << 8)
-        );
-        assertEq(reconstructed, value);
-    }
-
-    function testFuzz_RoundtripSigned32(int32 value) public pure {
-        bytes4 le = LittleEndian.toLittleEndianI32(value);
-        int32 reconstructed = int32(
-            uint32(uint8(le[0])) |
-                (uint32(uint8(le[1])) << 8) |
-                (uint32(uint8(le[2])) << 16) |
-                (uint32(uint8(le[3])) << 24)
-        );
-        assertEq(reconstructed, value);
-    }
-
-    // ============ fromLittleEndian unsigned ============
-
-    function test_FromLE8_Basic() public pure {
-        assertEq(LittleEndian.fromLittleEndianU8(bytes1(0xAB)), 0xAB);
-    }
-
-    function test_FromLE16_Basic() public pure {
-        // 0xCDAB (LE) → 0xABCD
-        assertEq(LittleEndian.fromLittleEndianU16(bytes2(0xCDAB)), 0xABCD);
-    }
-
-    function test_FromLE32_Basic() public pure {
-        // 0x78563412 (LE) → 0x12345678
-        assertEq(
-            LittleEndian.fromLittleEndianU32(bytes4(0x78563412)),
-            0x12345678
-        );
-    }
-
-    function test_FromLE64_Basic() public pure {
-        // 0x0807060504030201 (LE) → 0x0102030405060708
-        assertEq(
-            LittleEndian.fromLittleEndianU64(bytes8(0x0807060504030201)),
-            0x0102030405060708
-        );
-    }
-
-    function test_FromLE128_Basic() public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianU128(
-                bytes16(0x100f0e0d0c0b0a090807060504030201)
-            ),
-            0x0102030405060708090a0b0c0d0e0f10
-        );
-    }
-
-    function test_FromLE256_Basic() public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianU256(
-                bytes32(
-                    0x201f1e1d1c1b1a191817161514131211100f0e0d0c0b0a090807060504030201
-                )
-            ),
-            0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20
-        );
-    }
-
-    // ============ fromLittleEndian signed ============
-
-    function test_FromLEi8_Negative() public pure {
-        assertEq(LittleEndian.fromLittleEndianI8(bytes1(0xff)), int8(-1));
-    }
-
-    function test_FromLEi16_Negative() public pure {
-        assertEq(LittleEndian.fromLittleEndianI16(bytes2(0xffff)), int16(-1));
-    }
-
-    function test_FromLEi16_Neg256() public pure {
-        // 0x00ff (LE) → 0xff00 (BE) → -256
-        assertEq(LittleEndian.fromLittleEndianI16(bytes2(0x00ff)), int16(-256));
-    }
-
-    function test_FromLEi32_Negative() public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianI32(bytes4(0xffffffff)),
-            int32(-1)
-        );
-    }
-
-    function test_FromLEi32_Min() public pure {
-        // 0x00000080 (LE) → 0x80000000 (BE) → int32.min
-        assertEq(
-            LittleEndian.fromLittleEndianI32(bytes4(0x00000080)),
-            type(int32).min
-        );
-    }
-
-    function test_FromLEi64_Negative() public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianI64(bytes8(0xffffffffffffffff)),
-            int64(-1)
-        );
-    }
-
-    function test_FromLEi128_Negative() public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianI128(
-                bytes16(0xffffffffffffffffffffffffffffffff)
-            ),
-            int128(-1)
-        );
-    }
-
-    function test_FromLEi256_Negative() public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianI256(bytes32(type(uint256).max)),
-            int256(-1)
-        );
-    }
-
-    // ============ Fuzz roundtrip: toLE → fromLE ============
-
-    function testFuzz_RoundtripFromLE8(uint8 value) public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianU8(
-                LittleEndian.toLittleEndianU8(value)
-            ),
-            value
-        );
-    }
-
-    function testFuzz_RoundtripFromLE16(uint16 value) public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianU16(
-                LittleEndian.toLittleEndianU16(value)
-            ),
-            value
-        );
-    }
-
-    function testFuzz_RoundtripFromLE32(uint32 value) public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianU32(
-                LittleEndian.toLittleEndianU32(value)
-            ),
-            value
-        );
-    }
-
-    function testFuzz_RoundtripFromLE64(uint64 value) public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianU64(
-                LittleEndian.toLittleEndianU64(value)
-            ),
-            value
-        );
-    }
-
-    function testFuzz_RoundtripFromLE128(uint128 value) public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianU128(
-                LittleEndian.toLittleEndianU128(value)
-            ),
-            value
-        );
-    }
-
-    function testFuzz_RoundtripFromLE256(uint256 value) public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianU256(
-                LittleEndian.toLittleEndianU256(value)
-            ),
-            value
-        );
-    }
-
-    function testFuzz_RoundtripFromLEi16(int16 value) public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianI16(
-                LittleEndian.toLittleEndianI16(value)
-            ),
-            value
-        );
-    }
-
-    function testFuzz_RoundtripFromLEi32(int32 value) public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianI32(
-                LittleEndian.toLittleEndianI32(value)
-            ),
-            value
-        );
-    }
-
-    function testFuzz_RoundtripFromLEi64(int64 value) public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianI64(
-                LittleEndian.toLittleEndianI64(value)
-            ),
-            value
-        );
-    }
-
-    function testFuzz_RoundtripFromLEi128(int128 value) public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianI128(
-                LittleEndian.toLittleEndianI128(value)
-            ),
-            value
-        );
-    }
-
-    function testFuzz_RoundtripFromLEi256(int256 value) public pure {
-        assertEq(
-            LittleEndian.fromLittleEndianI256(
-                LittleEndian.toLittleEndianI256(value)
-            ),
-            value
-        );
-    }
-}