solidity-scale-codec 0.1.0

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

@@ -0,0 +1,326 @@
+// 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/Scale/Compact.sol

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Compact} from "./Compact/Compact.sol";

package/src/Scale/Signed/I128.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import { U128 } from "../Unsigned/U128.sol";
+
+/// @title Scale Codec for the `int128` type.
+/// @notice SCALE-compliant encoder/decoder for the `int128` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+library I128 {
+	/// @notice Encodes an `int128` into SCALE format (16-byte two's-complement little-endian).
+    /// @param value The signed 128-bit integer to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(int128 value) internal pure returns (bytes memory) {
+        return abi.encodePacked(toLittleEndian(value));
+    }
+
+    /// @notice Decodes SCALE-encoded bytes into an `int128`.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return The decoded `int128`.
+    function decode(bytes memory data) internal pure returns (int128) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `int128` at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return value The decoded `int128`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (int128 value) {
+        return int128(U128.decodeAt(data, offset));
+    }
+
+	/// @notice Converts an int128 to little-endian bytes16 (two's complement)
+    function toLittleEndian(int128 value) internal pure returns (bytes16 result) {
+        return U128.toLittleEndian(uint128(value));
+    }
+}

package/src/Scale/Signed/I16.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import { U16 } from "../Unsigned/U16.sol";
+
+/// @title Scale Codec for the `int16` type.
+/// @notice SCALE-compliant encoder/decoder for the `int16` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+library I16 {
+	/// @notice Encodes an `int16` into SCALE format (2-byte two's-complement little-endian).
+    /// @param value The signed 16-bit integer to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(int16 value) internal pure returns (bytes memory) {
+        return abi.encodePacked(toLittleEndian(value));
+    }
+
+    /// @notice Decodes SCALE-encoded bytes into an `int16`.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return The decoded `int16`.
+    function decode(bytes memory data) internal pure returns (int16) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `int16` at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return value The decoded `int16`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (int16 value) {
+        return int16(U16.decodeAt(data, offset));
+    }
+
+	/// @notice Converts an int16 to little-endian bytes2 (two's complement)
+    function toLittleEndian(int16 value) internal pure returns (bytes2 result) {
+        return U16.toLittleEndian(uint16(value));
+    }
+}

package/src/Scale/Signed/I256.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import { U256 } from "../Unsigned/U256.sol";
+
+/// @title Scale Codec for the `int256` type.
+/// @notice SCALE-compliant encoder/decoder for the `int256` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+library I256 {
+	/// @notice Encodes an `int256` into SCALE format (32-byte two's-complement little-endian).
+    /// @param value The signed 256-bit integer to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(int256 value) internal pure returns (bytes memory) {
+        return abi.encodePacked(toLittleEndian(value));
+    }
+
+    /// @notice Decodes SCALE-encoded bytes into an `int256`.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return The decoded `int256`.
+    function decode(bytes memory data) internal pure returns (int256) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `int256` at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return value The decoded `int256`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (int256 value) {
+        return int256(U256.decodeAt(data, offset));
+    }
+
+	/// @notice Converts an int256 to little-endian bytes32 (two's complement)
+    function toLittleEndian(int256 value) internal pure returns (bytes32 result) {
+        return U256.toLittleEndian(uint256(value));
+    }
+}

package/src/Scale/Signed/I32.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import { U32 } from "../Unsigned/U32.sol";
+
+/// @title Scale Codec for the `int32` type.
+/// @notice SCALE-compliant encoder/decoder for the `int32` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+library I32 {
+	/// @notice Encodes an `int32` into SCALE format (4-byte two's-complement little-endian).
+    /// @param value The signed 32-bit integer to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(int32 value) internal pure returns (bytes memory) {
+        return abi.encodePacked(toLittleEndian(value));
+    }
+
+    /// @notice Decodes SCALE-encoded bytes into an `int32`.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return The decoded `int32`.
+    function decode(bytes memory data) internal pure returns (int32) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `int32` at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return value The decoded `int32`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (int32 value) {
+        return int32(U32.decodeAt(data, offset));
+    }
+
+	/// @notice Converts an int32 to little-endian bytes4 (two's complement)
+    function toLittleEndian(int32 value) internal pure returns (bytes4 result) {
+        return U32.toLittleEndian(uint32(value));
+    }
+}

package/src/Scale/Signed/I64.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import { U64 } from "../Unsigned/U64.sol";
+
+/// @title Scale Codec for the `int64` type.
+/// @notice SCALE-compliant encoder/decoder for the `int64` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+library I64 {
+	/// @notice Encodes an `int64` into SCALE format (8-byte two's-complement little-endian).
+    /// @param value The signed 64-bit integer to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(int64 value) internal pure returns (bytes memory) {
+        return abi.encodePacked(toLittleEndian(value));
+    }
+
+    /// @notice Decodes SCALE-encoded bytes into an `int64`.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return The decoded `int64`.
+    function decode(bytes memory data) internal pure returns (int64) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `int64` at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return value The decoded `int64`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (int64 value) {
+        return int64(U64.decodeAt(data, offset));
+    }
+
+	/// @notice Converts an int64 to little-endian bytes8 (two's complement)
+    function toLittleEndian(int64 value) internal pure returns (bytes8 result) {
+        return U64.toLittleEndian(uint64(value));
+    }
+}

package/src/Scale/Signed/I8.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import { U8 } from "../Unsigned/U8.sol";
+
+/// @title Scale Codec for the `int8` type.
+/// @notice SCALE-compliant encoder/decoder for the `int8` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+library I8 {
+	/// @notice Encodes an `int8` into SCALE format (1-byte two's-complement little-endian).
+    /// @param value The signed 8-bit integer to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(int8 value) internal pure returns (bytes memory) {
+        return abi.encodePacked(toLittleEndian(value));
+    }
+
+    /// @notice Decodes SCALE-encoded bytes into an `int8`.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return The decoded `int8`.
+    function decode(bytes memory data) internal pure returns (int8) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `int8` at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return value The decoded `int8`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (int8 value) {
+        return int8(U8.decodeAt(data, offset));
+    }
+
+	/// @notice Converts an int8 to little-endian bytes1 (two's complement)
+    function toLittleEndian(int8 value) internal pure returns (bytes1 result) {
+        return U8.toLittleEndian(uint8(value));
+    }
+}

package/src/Scale/Signed.sol

@@ -0,0 +1,10 @@
+
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20; 
+
+import { I8 } from "./Signed/I8.sol"; 
+import { I16 } from "./Signed/I16.sol"; 
+import { I32 } from "./Signed/I32.sol"; 
+import { I64 } from "./Signed/I64.sol"; 
+import { I128 } from "./Signed/I128.sol"; 
+import { I256 } from "./Signed/I256.sol"; 

package/src/Scale/Unsigned/U128.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+/// @title Scale Codec for the `uint128` type.
+/// @notice SCALE-compliant encoder/decoder for the `uint128` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+library U128 {
+	error InvalidU128Length();
+
+	/// @notice Encodes an `uint128` into SCALE format (16-byte little-endian).
+    /// @param value The unsigned 128-bit integer to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(uint128 value) internal pure returns (bytes memory) {
+        return abi.encodePacked(toLittleEndian(value));
+    }
+
+    /// @notice Decodes SCALE-encoded bytes into an `uint128`.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return The decoded `uint128`.
+    function decode(bytes memory data) internal pure returns (uint128) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `uint128` at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return value The decoded `uint128`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint128 value) {
+        if (data.length < offset + 16) revert InvalidU128Length();
+        assembly { let ptr := add(add(data, 32), offset) value := 0 for { let i := 0 } lt(i, 16) { i := add(i, 1) } { let b := and(mload(add(ptr, i)), 0xFF) value := or(value, shl(mul(i, 8), b)) } }
+    }
+
+	/// @notice Converts an `uint128` to little-endian bytes16
+	function toLittleEndian(uint128 value) internal pure returns (bytes16 result) {
+		assembly { let v := value v := or(shl(8, and(v, 0x00FF00FF00FF00FF00FF00FF00FF00FF)), shr(8, and(v, 0xFF00FF00FF00FF00FF00FF00FF00FF00))) v := or(shl(16, and(v, 0x0000FFFF0000FFFF0000FFFF0000FFFF)), shr(16, and(v, 0xFFFF0000FFFF0000FFFF0000FFFF0000))) v := or(shl(32, and(v, 0x00000000FFFFFFFF00000000FFFFFFFF)), shr(32, and(v, 0xFFFFFFFF00000000FFFFFFFF00000000))) v := or(shl(64, v), shr(64, v)) result := shl(128, v) }
+	}
+}

package/src/Scale/Unsigned/U16.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+/// @title Scale Codec for the `uint16` type.
+/// @notice SCALE-compliant encoder/decoder for the `uint16` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+library U16 {
+	error InvalidU16Length();
+
+	/// @notice Encodes an `uint16` into SCALE format (2-byte little-endian).
+    /// @param value The unsigned 16-bit integer to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(uint16 value) internal pure returns (bytes memory) {
+        return abi.encodePacked(toLittleEndian(value));
+    }
+
+    /// @notice Decodes SCALE-encoded bytes into an `uint16`.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return The decoded `uint16`.
+    function decode(bytes memory data) internal pure returns (uint16) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `uint16` at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return value The decoded `uint16`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint16 value) {
+        if (data.length < offset + 2) revert InvalidU16Length();
+        assembly { let ptr := add(add(data, 32), offset) let b0 := and(mload(ptr), 0xFF) let b1 := and(mload(add(ptr, 1)), 0xFF) value := or(b0, shl(8, b1)) }
+    }
+
+	/// @notice Converts an `uint16` to little-endian bytes2
+	function toLittleEndian(uint16 value) internal pure returns (bytes2 result) {
+		return bytes2(uint16((value >> 8) | (value << 8)));
+	}
+}