solidity-scale-codec 0.1.3 → 0.3.0

package/src/Scale/Array/I32Arr.sol

@@ -8,7 +8,7 @@ import {I32} from "../Signed.sol";
 /// @notice SCALE-compliant encoder/decoder for the `int32[]` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library I32Arr {
-    error InvalidI32ArrLenght();
+    error InvalidI32ArrLength();
 
     using I32 for int32;
 
@@ -23,6 +23,20 @@ library I32Arr {
         return result;
     }
 
+    /// @notice Returns the number of bytes that a `int32[]` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `int32[]`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `int32[]`.
+    /// @return The number of bytes that the `int32[]` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 4);
+        if (offset + totalSize > data.length) revert InvalidI32ArrLength();
+        return totalSize;
+    }
+
     /// @notice Decodes an `int32[]` from SCALE format.
     /// @param data The SCALE-encoded byte sequence.
     /// @return arr The decoded array of `int32`.
@@ -45,7 +59,7 @@ library I32Arr {
         (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
         uint256 pos = offset + compactBytes;
 
-        if (pos + (length * 4) > data.length) revert InvalidI32ArrLenght();
+        if (pos + (length * 4) > data.length) revert InvalidI32ArrLength();
 
         arr = new int32[](length);
         for (uint256 i = 0; i < length; ++i) {

package/src/Scale/Array/I64Arr.sol

@@ -8,7 +8,7 @@ import {I64} from "../Signed.sol";
 /// @notice SCALE-compliant encoder/decoder for the `int64[]` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library I64Arr {
-    error InvalidI64ArrLenght();
+    error InvalidI64ArrLength();
 
     using I64 for int64;
 
@@ -23,6 +23,20 @@ library I64Arr {
         return result;
     }
 
+    /// @notice Returns the number of bytes that a `int64[]` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `int64[]`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `int64[]`.
+    /// @return The number of bytes that the `int64[]` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 8);
+        if (offset + totalSize > data.length) revert InvalidI64ArrLength();
+        return totalSize;
+    }
+
     /// @notice Decodes an `int64[]` from SCALE format.
     /// @param data The SCALE-encoded byte sequence.
     /// @return arr The decoded array of `int64`.
@@ -45,7 +59,7 @@ library I64Arr {
         (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
         uint256 pos = offset + compactBytes;
 
-        if (pos + (length * 8) > data.length) revert InvalidI64ArrLenght();
+        if (pos + (length * 8) > data.length) revert InvalidI64ArrLength();
 
         arr = new int64[](length);
         for (uint256 i = 0; i < length; ++i) {

package/src/Scale/Array/I8Arr.sol

@@ -8,7 +8,7 @@ import {I8} from "../Signed.sol";
 /// @notice SCALE-compliant encoder/decoder for the `int8[]` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library I8Arr {
-    error InvalidI8ArrLenght();
+    error InvalidI8ArrLength();
 
     using I8 for int8;
 
@@ -23,6 +23,20 @@ library I8Arr {
         return result;
     }
 
+    /// @notice Returns the number of bytes that a `int8[]` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `int8[]`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `int8[]`.
+    /// @return The number of bytes that the `int8[]` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 1);
+        if (offset + totalSize > data.length) revert InvalidI8ArrLength();
+        return totalSize;
+    }
+
     /// @notice Decodes an `int8[]` from SCALE format.
     /// @param data The SCALE-encoded byte sequence.
     /// @return arr The decoded array of `int8`.
@@ -45,7 +59,7 @@ library I8Arr {
         (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
         uint256 pos = offset + compactBytes;
 
-        if (pos + (length * 1) > data.length) revert InvalidI8ArrLenght();
+        if (pos + (length * 1) > data.length) revert InvalidI8ArrLength();
 
         arr = new int8[](length);
         for (uint256 i = 0; i < length; ++i) {

package/src/Scale/Array/U128Arr.sol

@@ -8,7 +8,7 @@ import {U128} from "../Unsigned.sol";
 /// @notice SCALE-compliant encoder/decoder for the `uint128[]` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library U128Arr {
-    error InvalidU128ArrLenght();
+    error InvalidU128ArrLength();
 
     using U128 for uint128;
 
@@ -23,6 +23,20 @@ library U128Arr {
         return result;
     }
 
+    /// @notice Returns the number of bytes that a `uint128[]` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `uint128[]`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `uint128[]`.
+    /// @return The number of bytes that the `uint128[]` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 16);
+        if (offset + totalSize > data.length) revert InvalidU128ArrLength();
+        return totalSize;
+    }
+
     /// @notice Decodes an `uint128[]` from SCALE format.
     /// @param data The SCALE-encoded byte sequence.
     /// @return arr The decoded array of `uint128`.
@@ -45,7 +59,7 @@ library U128Arr {
         (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
         uint256 pos = offset + compactBytes;
 
-        if (pos + (length * 16) > data.length) revert InvalidU128ArrLenght();
+        if (pos + (length * 16) > data.length) revert InvalidU128ArrLength();
 
         arr = new uint128[](length);
         for (uint256 i = 0; i < length; ++i) {

package/src/Scale/Array/U16Arr.sol

@@ -8,7 +8,7 @@ import {U16} from "../Unsigned.sol";
 /// @notice SCALE-compliant encoder/decoder for the `uint16[]` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library U16Arr {
-    error InvalidU16ArrLenght();
+    error InvalidU16ArrLength();
 
     using U16 for uint16;
 
@@ -23,6 +23,20 @@ library U16Arr {
         return result;
     }
 
+    /// @notice Returns the number of bytes that a `uint16[]` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `uint16[]`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `uint16[]`.
+    /// @return The number of bytes that the `uint16[]` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 2);
+        if (offset + totalSize > data.length) revert InvalidU16ArrLength();
+        return totalSize;
+    }
+
     /// @notice Decodes an `uint16[]` from SCALE format.
     /// @param data The SCALE-encoded byte sequence.
     /// @return arr The decoded array of `uint16`.
@@ -45,7 +59,7 @@ library U16Arr {
         (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
         uint256 pos = offset + compactBytes;
 
-        if (pos + (length * 2) > data.length) revert InvalidU16ArrLenght();
+        if (pos + (length * 2) > data.length) revert InvalidU16ArrLength();
 
         arr = new uint16[](length);
         for (uint256 i = 0; i < length; ++i) {

package/src/Scale/Array/U256Arr.sol

@@ -8,7 +8,7 @@ import {U256} from "../Unsigned.sol";
 /// @notice SCALE-compliant encoder/decoder for the `uint256[]` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library U256Arr {
-    error InvalidU256ArrLenght();
+    error InvalidU256ArrLength();
 
     using U256 for uint256;
 
@@ -23,6 +23,20 @@ library U256Arr {
         return result;
     }
 
+    /// @notice Returns the number of bytes that a `uint256[]` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `uint256[]`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `uint256[]`.
+    /// @return The number of bytes that the `uint256[]` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 32);
+        if (offset + totalSize > data.length) revert InvalidU256ArrLength();
+        return totalSize;
+    }
+
     /// @notice Decodes an `uint256[]` from SCALE format.
     /// @param data The SCALE-encoded byte sequence.
     /// @return arr The decoded array of `uint256`.
@@ -45,7 +59,7 @@ library U256Arr {
         (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
         uint256 pos = offset + compactBytes;
 
-        if (pos + (length * 32) > data.length) revert InvalidU256ArrLenght();
+        if (pos + (length * 32) > data.length) revert InvalidU256ArrLength();
 
         arr = new uint256[](length);
         for (uint256 i = 0; i < length; ++i) {

package/src/Scale/Array/U32Arr.sol

@@ -8,7 +8,7 @@ import {U32} from "../Unsigned.sol";
 /// @notice SCALE-compliant encoder/decoder for the `uint32[]` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library U32Arr {
-    error InvalidU32ArrLenght();
+    error InvalidU32ArrLength();
 
     using U32 for uint32;
 
@@ -23,6 +23,20 @@ library U32Arr {
         return result;
     }
 
+    /// @notice Returns the number of bytes that a `uint32[]` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `uint32[]`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `uint32[]`.
+    /// @return The number of bytes that the `uint32[]` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 4);
+        if (offset + totalSize > data.length) revert InvalidU32ArrLength();
+        return totalSize;
+    }
+
     /// @notice Decodes an `uint32[]` from SCALE format.
     /// @param data The SCALE-encoded byte sequence.
     /// @return arr The decoded array of `uint32`.
@@ -45,7 +59,7 @@ library U32Arr {
         (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
         uint256 pos = offset + compactBytes;
 
-        if (pos + (length * 4) > data.length) revert InvalidU32ArrLenght();
+        if (pos + (length * 4) > data.length) revert InvalidU32ArrLength();
 
         arr = new uint32[](length);
         for (uint256 i = 0; i < length; ++i) {

package/src/Scale/Array/U64Arr.sol

@@ -8,7 +8,7 @@ import {U64} from "../Unsigned.sol";
 /// @notice SCALE-compliant encoder/decoder for the `uint64[]` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library U64Arr {
-    error InvalidU64ArrLenght();
+    error InvalidU64ArrLength();
 
     using U64 for uint64;
 
@@ -23,6 +23,20 @@ library U64Arr {
         return result;
     }
 
+    /// @notice Returns the number of bytes that a `uint64[]` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `uint64[]`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `uint64[]`.
+    /// @return The number of bytes that the `uint64[]` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 8);
+        if (offset + totalSize > data.length) revert InvalidU64ArrLength();
+        return totalSize;
+    }
+
     /// @notice Decodes an `uint64[]` from SCALE format.
     /// @param data The SCALE-encoded byte sequence.
     /// @return arr The decoded array of `uint64`.
@@ -45,7 +59,7 @@ library U64Arr {
         (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
         uint256 pos = offset + compactBytes;
 
-        if (pos + (length * 8) > data.length) revert InvalidU64ArrLenght();
+        if (pos + (length * 8) > data.length) revert InvalidU64ArrLength();
 
         arr = new uint64[](length);
         for (uint256 i = 0; i < length; ++i) {

package/src/Scale/Array/U8Arr.sol

@@ -8,7 +8,7 @@ import {U8} from "../Unsigned.sol";
 /// @notice SCALE-compliant encoder/decoder for the `uint8[]` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library U8Arr {
-    error InvalidU8ArrLenght();
+    error InvalidU8ArrLength();
 
     using U8 for uint8;
 
@@ -23,6 +23,20 @@ library U8Arr {
         return result;
     }
 
+    /// @notice Returns the number of bytes that a `uint8[]` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `uint8[]`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `uint8[]`.
+    /// @return The number of bytes that the `uint8[]` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 1);
+        if (offset + totalSize > data.length) revert InvalidU8ArrLength();
+        return totalSize;
+    }
+
     /// @notice Decodes an `uint8[]` from SCALE format.
     /// @param data The SCALE-encoded byte sequence.
     /// @return arr The decoded array of `uint8`.
@@ -45,7 +59,7 @@ library U8Arr {
         (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
         uint256 pos = offset + compactBytes;
 
-        if (pos + (length * 1) > data.length) revert InvalidU8ArrLenght();
+        if (pos + (length * 1) > data.length) revert InvalidU8ArrLength();
 
         arr = new uint8[](length);
         for (uint256 i = 0; i < length; ++i) {

package/src/Scale/Bool/Bool.sol

@@ -14,6 +14,18 @@ library Bool {
         return abi.encodePacked(value ? bytes1(0x01) : bytes1(0x00));
     }
 
+    /// @notice Returns the number of bytes that a `bool` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `bool`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `bool`.
+    /// @return The number of bytes that the `bool` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (data.length < offset + 1) revert InvalidLength();
+        return 1;
+    }
+
     /// @notice Decodes SCALE-encoded bytes into a `bool`.
     /// @param data The SCALE-encoded byte sequence.
     /// @return The decoded boolean.

package/src/Scale/Bytes/Bytes.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Compact} from "../../Scale/Compact.sol";
+
+/// @title Scale Codec for the `bytes` type.
+/// @notice SCALE-compliant encoder/decoder for the `bytes` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+library Bytes {
+    error InvalidBytesLength();
+
+    /// @notice Encodes an `bytes` into SCALE format.
+    /// @param value The `bytes` to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(bytes memory value) internal pure returns (bytes memory) {
+        return abi.encodePacked(Compact.encode(value.length), value);
+    }
+
+    /// @notice Returns the number of bytes that a `bytes` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `bytes`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `bytes`.
+    /// @return The number of bytes that the `bytes` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        (uint256 length, uint256 lengthBytes) = Compact.decodeAt(data, offset);
+        if (data.length < offset + lengthBytes + length) {
+            revert InvalidBytesLength();
+        }
+        return lengthBytes + length;
+    }
+
+    /// @notice Decodes SCALE-encoded bytes into an `bytes`.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return value The decoded `bytes`.
+    /// @return bytesRead The number of bytes read from the input.
+    function decode(
+        bytes memory data
+    ) internal pure returns (bytes memory value, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `bytes` from SCALE format at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return value The decoded `bytes`.
+    /// @return bytesRead The number of bytes read from the input.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (bytes memory value, uint256 bytesRead) {
+        (uint256 length, uint256 lengthBytes) = Compact.decodeAt(data, offset);
+        if (data.length < offset + lengthBytes + length) {
+            revert InvalidBytesLength();
+        }
+        value = new bytes(length);
+        bytesRead = lengthBytes + length;
+        for (uint256 i = 0; i < length; i++) {
+            value[i] = data[offset + lengthBytes + i];
+        }
+    }
+}

package/src/Scale/Bytes/Bytes16.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+/// @title Scale Codec for the `bytes16` type.
+/// @notice SCALE-compliant encoder/decoder for the `bytes16` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+library Bytes16 {
+    error InvalidBytes16Length();
+
+    /// @notice Encodes an `bytes16` into SCALE format.
+    /// @param value The `bytes16` to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(bytes16 value) internal pure returns (bytes memory) {
+        return abi.encodePacked(value);
+    }
+
+    /// @notice Returns the number of bytes that a `bytes16` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `bytes16`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `bytes16`.
+    /// @return The number of bytes that the `bytes16` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (data.length < offset + 16) {
+            revert InvalidBytes16Length();
+        }
+        return 16;
+    }
+
+    /// @notice Decodes SCALE-encoded bytes into an `bytes16`.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return The decoded `bytes16`.
+    function decode(bytes memory data) internal pure returns (bytes16) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `bytes16` from SCALE format at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return value The decoded `bytes16`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (bytes16 value) {
+        if (data.length < offset + 16) {
+            revert InvalidBytes16Length();
+        }
+        assembly {
+            value := mload(add(add(data, 32), offset))
+        }
+    }
+}

package/src/Scale/Bytes/Bytes2.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+/// @title Scale Codec for the `bytes2` type.
+/// @notice SCALE-compliant encoder/decoder for the `bytes2` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+library Bytes2 {
+    error InvalidBytes2Length();
+
+    /// @notice Encodes an `bytes2` into SCALE format.
+    /// @param value The `bytes2` to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(bytes2 value) internal pure returns (bytes memory) {
+        return abi.encodePacked(value);
+    }
+
+    /// @notice Returns the number of bytes that a `bytes2` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `bytes2`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `bytes2`.
+    /// @return The number of bytes that the `bytes2` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (data.length < offset + 2) {
+            revert InvalidBytes2Length();
+        }
+        return 2;
+    }
+
+    /// @notice Decodes SCALE-encoded bytes into an `bytes2`.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return The decoded `bytes2`.
+    function decode(bytes memory data) internal pure returns (bytes2) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `bytes2` from SCALE format at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return value The decoded `bytes2`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (bytes2 value) {
+        if (data.length < offset + 2) {
+            revert InvalidBytes2Length();
+        }
+        assembly {
+            value := mload(add(add(data, 32), offset))
+        }
+    }
+}

package/src/Scale/Bytes/Bytes32.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+/// @title Scale Codec for the `bytes32` type.
+/// @notice SCALE-compliant encoder/decoder for the `bytes32` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+library Bytes32 {
+    error InvalidBytes32Length();
+
+    /// @notice Encodes an `bytes32` into SCALE format.
+    /// @param value The `bytes32` to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(bytes32 value) internal pure returns (bytes memory) {
+        return abi.encodePacked(value);
+    }
+
+    /// @notice Returns the number of bytes that a `bytes32` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `bytes32`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `bytes32`.
+    /// @return The number of bytes that the `bytes32` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (data.length < offset + 32) {
+            revert InvalidBytes32Length();
+        }
+        return 32;
+    }
+
+    /// @notice Decodes SCALE-encoded bytes into an `bytes32`.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return The decoded `bytes32`.
+    function decode(bytes memory data) internal pure returns (bytes32) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `bytes32` from SCALE format at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return value The decoded `bytes32`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (bytes32 value) {
+        if (data.length < offset + 32) {
+            revert InvalidBytes32Length();
+        }
+        assembly {
+            value := mload(add(add(data, 32), offset))
+        }
+    }
+}

package/src/Scale/Bytes/Bytes4.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+/// @title Scale Codec for the `bytes4` type.
+/// @notice SCALE-compliant encoder/decoder for the `bytes4` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+library Bytes4 {
+    error InvalidBytes4Length();
+
+    /// @notice Encodes an `bytes4` into SCALE format.
+    /// @param value The `bytes4` to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(bytes4 value) internal pure returns (bytes memory) {
+        return abi.encodePacked(value);
+    }
+
+    /// @notice Returns the number of bytes that a `bytes4` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `bytes4`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `bytes4`.
+    /// @return The number of bytes that the `bytes4` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (data.length < offset + 4) {
+            revert InvalidBytes4Length();
+        }
+        return 4;
+    }
+
+    /// @notice Decodes SCALE-encoded bytes into an `bytes4`.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return The decoded `bytes4`.
+    function decode(bytes memory data) internal pure returns (bytes4) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `bytes4` from SCALE format at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return value The decoded `bytes4`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (bytes4 value) {
+        if (data.length < offset + 4) {
+            revert InvalidBytes4Length();
+        }
+        assembly {
+            value := mload(add(add(data, 32), offset))
+        }
+    }
+}