solidity-scale-codec 2.1.1 → 2.1.2

package/guides/Definitions.md

@@ -0,0 +1,186 @@
+> Note: These definitions were taken from https://github.com/w3f/polkadot-spec/blob/main/docs. They are provided here for reference. All credits to respective authors.
+
+# SCALE
+
+The Polkadot Host uses _Simple Concatenated Aggregate Little-Endian” (SCALE) codec_ to encode byte arrays as well as other data structures. SCALE provides a canonical encoding to produce consistent hash values across their implementation, including the Merkle hash proof for the State Storage.
+
+## Decoding
+
+$\text{Dec}_{{\text{SC}}}{\left({d}\right)}$ refers to the decoding of a blob of data. Since the SCALE codec is not self-describing, it’s up to the decoder to validate whether the blob of data can be deserialized into the given type or data structure.
+
+It’s accepted behavior for the decoder to partially decode the blob of data. This means any additional data that does not fit into a data structure can be ignored.
+
+> caution
+> Considering that the decoded data is never larger than the encoded message, this information can serve as a way to validate values that can vary in size, such as [sequences](#sequence). The decoder should strictly use the size of the encoded data as an upper bound when decoding in order to prevent denial of service attacks.
+
+# Notation
+
+- Let $\mathbb{{B}}$ be the set of all byte sequences.
+- Let $x \in \mathbb{{B}}$, $x_i$ denotes the $i$-th byte of $x$, and $x_i^j$ denotes the $j$-th bit of the $i$-th byte of $x$.
+
+# Definitions
+
+## Little Endian
+
+By the **little-endian** representation of a non-negative integer, ${I}$, represented as
+
+$$
+{I}={\left({B}_{{n}}\ldots{B}_{{0}}\right)}_{{256}}
+$$
+
+in base 256, we refer to a byte array ${B}={\left({b}_{{0}},{b}_{{1}},\ldots,{b}_{{n}}\right)}$ such that
+
+$$
+{b}_{{i}}\:={B}_{{i}}
+$$
+
+Accordingly, we define the function ${\mathsf{\text{Enc}}}_{{{\mathsf{\text{LE}}}}}$:
+
+$$
+{\mathsf{\text{Enc}}}_{{{\mathsf{\text{LE}}}}}:{\mathbb{{Z}}}^{+}\rightarrow{\mathbb{{B}}};{\left({B}_{{n}}\ldots{B}_{{0}}\right)}_{{256}}{\mid}\rightarrow{\left({B}_{{{0},}}{B}_{{1}},\ldots,{B}_{{n}}\right)}
+$$
+
+## Scale Types
+
+### Fixed Length Integers
+
+The SCALE codec, $\text{Enc}_{{\text{SC}}}$, for fixed length integers not defined here otherwise, is equal to the little-endian encoding of those values.
+
+### Tuple
+
+The **SCALE codec** for **Tuple**, ${T}$, such that:
+
+$$
+{T}\:={\left({A}_{{1}},\ldots{A}_{{n}}\right)}
+$$
+
+Where ${A}_{{i}}$’s are values of **different types**, is defined as:
+
+$$
+\text{Enc}_{{\text{SC}}}{\left({T}\right)}\:=\text{Enc}_{{\text{SC}}}{\left({A}_{{1}}\right)}\text{||}\text{Enc}_{{\text{SC}}}{\left({A}_{{2}}\right)}\text{||}\ldots\text{||}\text{Enc}_{{\text{SC}}}{\left({A}_{{n}}\right)}
+$$
+
+In the case of a tuple (or a structure), the knowledge of the shape of data is not encoded even though it is necessary for decoding. The decoder needs to derive that information from the context where the encoding/decoding is happening.
+
+### Varying Data Type
+
+> This library does not provide means for encoding/decoding varying data types, but the definitions are provided here for completeness and reference. The implementation is left to the user of the library.
+
+We define a **varying data** type to be an ordered set of data types.
+
+$$
+{\mathcal{{T}}}={\left\lbrace{T}_{{1}},\ldots,{T}_{{n}}\right\rbrace}
+$$
+
+A value ${A}$ of varying data type is a pair ${\left({A}_{{\text{Type}}},{A}_{{\text{Value}}}\right)}$ where ${A}_{{\text{Type}}}={T}_{{i}}$ for some ${T}_{{i}}\in{\mathcal{{T}}}$ and ${A}_{{\text{Value}}}$ is its value of type ${T}_{{i}}$, which can be empty. We define $\text{idx}{\left({T}_{{i}}\right)}={i}-{1}$, unless it is explicitly defined as another value in the definition of a particular varying data type.
+
+The SCALE codec for value ${A}={\left({A}_{{\text{Type}}},{A}_{{\text{Value}}}\right)}$ of varying data type ${\mathcal{{T}}}={\left\lbrace{T}_{{i}},\ldots{T}_{{n}}\right\rbrace}$, formally referred to as $\text{Enc}_{{\text{SC}}}{\left({A}\right)}$ is defined as follows:
+
+$$
+\text{Enc}_{{\text{SC}}}{\left({A}\right)}\:=\text{Enc}_{{\text{SC}}}{\left(\text{idx}{\left({A}_{{\text{Type}}}\right)}\text{||}\text{Enc}_{{\text{SC}}}{\left({A}_{{\text{Value}}}\right)}\right)}
+$$
+
+The SCALE codec does not encode the correspondence between the value and the data type it represents; the decoder needs prior knowledge of such correspondence to decode the data.
+
+### Boolean
+
+The SCALE codec for a **boolean value** ${b}$ defined as a byte as follows:
+
+$$
+\text{Enc}_{{\text{SC}}}:{\left\lbrace\text{False},\text{True}\right\rbrace}\rightarrow{\mathbb{{B}}}_{{1}}
+$$
+
+$$
+{b}\rightarrow{\left\lbrace\begin{matrix}{0}&{b}=\text{False}\\{1}&{b}=\text{True}\end{matrix}\right.}
+$$
+
+### Compact
+
+**SCALE Length encoding** ${\text{Enc}_{{\text{SC}}}^{{\text{Len}}}}$, also known as a _compact encoding_, of a non-negative number ${n}$ is defined as follows:
+
+$$
+{\text{Enc}_{{\text{SC}}}^{{\text{Len}}}}:{\mathbb{{N}}}\rightarrow{\mathbb{{B}}}
+$$
+
+$$
+{n}\rightarrow{b}\:={\left\lbrace\begin{matrix}{l}_{{1}}&{0}\le{n}<{2}^{{6}}\\{i}_{{1}}{i}_{{2}}&{2}^{{6}}\le{n}<{2}^{{14}}\\{j}_{{1}}{j}_{{2}}{j}_{{3}}{j}_{{4}}&{2}^{{14}}\le{n}<{2}^{{30}}\\{k}_{{1}}{k}_{{2}}\ldots{k}_{{m}+{1}}&{2}^{{30}}\le{n}\end{matrix}\right.}
+$$
+
+$$
+{{l}_{{1}}^{{1}}}{{l}_{{1}}^{{0}}}={00}
+$$
+
+$$
+{{i}_{{1}}^{{1}}}{{i}_{{1}}^{{0}}}={01}
+$$
+
+$$
+{{j}_{{1}}^{{1}}}{{j}_{{1}}^{{0}}}={10}
+$$
+
+$$
+{{k}_{{1}}^{{1}}}{{k}_{{1}}^{{0}}}={11}
+$$
+
+and the rest of the bits of ${b}$ store the value of ${n}$ in little-endian format in base-2 as follows:
+
+$$
+{n}\:={\left\lbrace\begin{matrix}{{l}_{{1}}^{{7}}}\ldots{{l}_{{1}}^{{3}}}{{l}_{{1}}^{{2}}}&{n}<{2}^{{6}}\\{{i}_{{2}}^{{7}}}\ldots{{i}_{{2}}^{{0}}}{{i}_{{1}}^{{7}}}..{{i}_{{1}}^{{2}}}&{2}^{{6}}\le{n}<{2}^{{14}}\\{{j}_{{4}}^{{7}}}\ldots{{j}_{{4}}^{{0}}}{{j}_{{3}}^{{7}}}\ldots{{j}_{{1}}^{{7}}}\ldots{{j}_{{1}}^{{2}}}&{2}^{{14}}\le{n}<{2}^{{30}}\\{k}_{{2}}+{k}_{{3}}{2}^{{8}}+{k}_{{4}}{2}^{{{2}\times{8}}}+\ldots+{k}_{{m}+{1}}{2}^{{{\left({m}-{1}\right)}{8}}}&{2}^{{30}}\le{n}\end{matrix}\right.}
+$$
+
+such that:
+
+$$
+{{k}_{{1}}^{{7}}}\ldots{{k}_{{1}}^{{3}}}{{k}_{{1}}^{{2}}}\:={m}-{4}
+$$
+
+Note that ${m}$ denotes the length of the original integer being encoded and does not include the extra byte describing the length. The encoding can be used for integers up to: $$2^{(63+4)8} -1 = 2^{536} -1$$
+
+### Sequence
+
+The **SCALE codec** for **sequence** ${S}$ such that:
+
+$$
+{S}\:={A}_{{1}},\ldots{A}_{{n}}
+$$
+
+where ${A}_{{i}}$’s are values of **the same type** (and the decoder is unable to infer value of ${n}$ from the context) is defined as:
+
+$$
+\text{Enc}_{{\text{SC}}}{\left({S}\right)}\:={\text{Enc}_{{\text{SC}}}^{{\text{Len}}}}{\left({\left|{{S}}\right|}\right)}\text{||}\text{Enc}_{{\text{SC}}}{\left({A}_{{2}}\right)}\text{||}\ldots\text{||}\text{Enc}_{{\text{SC}}}{\left({A}_{{n}}\right)}
+$$
+
+where ${\text{Enc}_{{\text{SC}}}^{{\text{Len}}}}$ is defined [here](#compact).
+
+In some cases, the length indicator ${\text{Enc}_{{\text{SC}}}^{{\text{Len}}}}{\left({\left|{{S}}\right|}\right)}$ is omitted if the length of the sequence is fixed and known by the decoder upfront. Such cases are explicitly stated by the definition of the corresponding type.
+
+### String
+
+The SCALE codec for a **string value** is an [encoded sequence](#sequence) consisting of UTF-8 encoded bytes.
+
+> This can be achieved via encoding the UTF-8 sequence as a `uint8[]` or `bytes`, which is supported by this library.
+
+### Option Type
+
+The **Option** type is a varying data type of ${\left\lbrace\text{None},{T}_{{2}}\right\rbrace}$ which indicates if data of ${T}_{{2}}$ type is available (referred to as _some_ state) or not (referred to as _empty_, _none_ or _null_ state). The presence of type _none_, indicated by $\text{idx}{\left({T}_{{\text{None}}}\right)}={0}$, implies that the data corresponding to ${T}_{{2}}$ type is not available and contains no additional data. Where as the presence of type ${T}_{{2}}$ indicated by $\text{idx}{\left({T}_{{2}}\right)}={1}$ implies that the data is available.
+
+### Result Type
+
+The **Result** type is a varying data type of ${\left\lbrace{T}_{{1}},{T}_{{2}}\right\rbrace}$ which is used to indicate if a certain operation or function was executed successfully (referred to as "ok" state) or not (referred to as "error" state). ${T}_{{1}}$ implies success, ${T}_{{2}}$ implies failure. Both types can either contain additional data or are defined as empty types otherwise.
+
+### Dictionaries, Hashtables, Maps
+
+SCALE codec for **dictionary** or **hashtable** D with key-value pairs
+$({k}_{{i}},{v}_{{i}})$, such that:
+
+$$
+{D}\:={\left\lbrace{\left({k}_{{1}},{v}_{{1}}\right)},\ldots{\left({k}_{{n}},{v}_{{n}}\right)}\right\rbrace}
+$$
+
+is defined as the SCALE codec of ${D}$ as a sequence of key-value pairs (as tuples):
+
+$$
+\text{Enc}_{{\text{SC}}}{\left({D}\right)}\:={\text{Enc}_{{\text{SC}}}^{{\text{Size}}}}{\left({\left|{{D}}\right|}\right)}\text{||}\text{Enc}_{{\text{SC}}}{\left({k}_{{1}},{v}_{{1}}\right)}\text{||}\ldots\text{||}\text{Enc}_{{\text{SC}}}{\left({k}_{{n}},{v}_{{n}}\right)}
+$$
+
+where ${\text{Enc}_{{\text{SC}}}^{{\text{Size}}}}$ is encoded the same way as ${\text{Enc}_{{\text{SC}}}^{{\text{Len}}}}$ but argument $\text{Size}$ refers to the number of key-value pairs rather than the length.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solidity-scale-codec",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "Solidity implementation of scale-codec.",
   "keywords": [
     "solidity",
@@ -21,7 +21,7 @@
     "README.md",
     "LICENSE",
     "CHANGELOG.md",
-    "DEFINITIONS.md"
+    "guides/Definitions.md"
   ],
   "license": "Apache-2.0",
   "author": "LucasGrasso",

package/src/Scale/Array/BoolArr.sol

@@ -31,9 +31,9 @@ library BoolArr {
         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 InvalidBoolArrLength();
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 1);
+        if (offset + totalSize > data.length) revert InvalidBoolArrLength();
         return totalSize;
     }
 

package/src/Scale/Array/I128Arr.sol

@@ -31,9 +31,9 @@ library I128Arr {
         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 InvalidI128ArrLength();
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 16);
+        if (offset + totalSize > data.length) revert InvalidI128ArrLength();
         return totalSize;
     }
 

package/src/Scale/Array/I16Arr.sol

@@ -31,9 +31,9 @@ library I16Arr {
         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 InvalidI16ArrLength();
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 2);
+        if (offset + totalSize > data.length) revert InvalidI16ArrLength();
         return totalSize;
     }
 

package/src/Scale/Array/I256Arr.sol

@@ -31,9 +31,9 @@ library I256Arr {
         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 InvalidI256ArrLength();
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 32);
+        if (offset + totalSize > data.length) revert InvalidI256ArrLength();
         return totalSize;
     }
 

package/src/Scale/Array/I32Arr.sol

@@ -31,9 +31,9 @@ library I32Arr {
         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();
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 4);
+        if (offset + totalSize > data.length) revert InvalidI32ArrLength();
         return totalSize;
     }
 

package/src/Scale/Array/I64Arr.sol

@@ -31,9 +31,9 @@ library I64Arr {
         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();
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 8);
+        if (offset + totalSize > data.length) revert InvalidI64ArrLength();
         return totalSize;
     }
 

package/src/Scale/Array/I8Arr.sol

@@ -31,9 +31,9 @@ library I8Arr {
         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();
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 1);
+        if (offset + totalSize > data.length) revert InvalidI8ArrLength();
         return totalSize;
     }
 

package/src/Scale/Array/U128Arr.sol

@@ -31,9 +31,9 @@ library U128Arr {
         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();
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 16);
+        if (offset + totalSize > data.length) revert InvalidU128ArrLength();
         return totalSize;
     }
 

package/src/Scale/Array/U16Arr.sol

@@ -31,9 +31,9 @@ library U16Arr {
         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();
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 2);
+        if (offset + totalSize > data.length) revert InvalidU16ArrLength();
         return totalSize;
     }
 

package/src/Scale/Array/U256Arr.sol

@@ -31,9 +31,9 @@ library U256Arr {
         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();
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 32);
+        if (offset + totalSize > data.length) revert InvalidU256ArrLength();
         return totalSize;
     }
 

package/src/Scale/Array/U32Arr.sol

@@ -31,9 +31,9 @@ library U32Arr {
         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();
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 4);
+        if (offset + totalSize > data.length) revert InvalidU32ArrLength();
         return totalSize;
     }
 

package/src/Scale/Array/U64Arr.sol

@@ -31,9 +31,9 @@ library U64Arr {
         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();
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 8);
+        if (offset + totalSize > data.length) revert InvalidU64ArrLength();
         return totalSize;
     }
 

package/src/Scale/Array/U8Arr.sol

@@ -31,9 +31,9 @@ library U8Arr {
         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();
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 1);
+        if (offset + totalSize > data.length) revert InvalidU8ArrLength();
         return totalSize;
     }
 

package/src/Scale/Array.sol

@@ -1,17 +1,16 @@
-
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.28; 
+pragma solidity ^0.8.28;
 
-import { U8Arr } from "./Array/U8Arr.sol"; 
-import { U16Arr } from "./Array/U16Arr.sol"; 
-import { U32Arr } from "./Array/U32Arr.sol"; 
-import { U64Arr } from "./Array/U64Arr.sol"; 
-import { U128Arr } from "./Array/U128Arr.sol"; 
-import { U256Arr } from "./Array/U256Arr.sol"; 
-import { I8Arr } from "./Array/I8Arr.sol"; 
-import { I16Arr } from "./Array/I16Arr.sol"; 
-import { I32Arr } from "./Array/I32Arr.sol"; 
-import { I64Arr } from "./Array/I64Arr.sol"; 
-import { I128Arr } from "./Array/I128Arr.sol"; 
-import { I256Arr } from "./Array/I256Arr.sol"; 
-import { BoolArr } from "./Array/BoolArr.sol"; 
+import {U8Arr} from "./Array/U8Arr.sol";
+import {U16Arr} from "./Array/U16Arr.sol";
+import {U32Arr} from "./Array/U32Arr.sol";
+import {U64Arr} from "./Array/U64Arr.sol";
+import {U128Arr} from "./Array/U128Arr.sol";
+import {U256Arr} from "./Array/U256Arr.sol";
+import {I8Arr} from "./Array/I8Arr.sol";
+import {I16Arr} from "./Array/I16Arr.sol";
+import {I32Arr} from "./Array/I32Arr.sol";
+import {I64Arr} from "./Array/I64Arr.sol";
+import {I128Arr} from "./Array/I128Arr.sol";
+import {I256Arr} from "./Array/I256Arr.sol";
+import {BoolArr} from "./Array/BoolArr.sol";

package/src/Scale/Compact/Compact.sol

@@ -105,14 +105,12 @@ library Compact {
         } else if (mode == MODE_TWO) {
             if (data.length < offset + 2) revert OffsetOutOfBounds();
             value =
-                uint256(LittleEndianU16.fromLittleEndian(data, offset)) >>
-                2;
+                uint256(LittleEndianU16.fromLittleEndian(data, offset)) >> 2;
             bytesRead = 2;
         } else if (mode == MODE_FOUR) {
             if (data.length < offset + 4) revert OffsetOutOfBounds();
             value =
-                uint256(LittleEndianU32.fromLittleEndian(data, offset)) >>
-                2;
+                uint256(LittleEndianU32.fromLittleEndian(data, offset)) >> 2;
             bytesRead = 4;
         } else {
             uint8 m = (header >> 2) + 4;

package/src/Scale/Signed/I128.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.28;
 
-import { U128 } from "../Unsigned/U128.sol";
+import {U128} from "../Unsigned/U128.sol";
 
 /// @title Scale Codec for the `int128` type.
 /// @notice SCALE-compliant encoder/decoder for the `int128` type.
@@ -9,7 +9,7 @@ import { U128 } from "../Unsigned/U128.sol";
 library I128 {
     error OffsetOutOfBounds();
 
-	/// @notice Encodes an `int128` into SCALE format (16-byte two's-complement little-endian).
+    /// @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) {
@@ -17,10 +17,13 @@ library I128 {
     }
 
     /// @notice Returns the number of bytes that a `int128` would occupy when SCALE-encoded.
-	/// @param data The byte sequence containing the encoded `int128`.
-	/// @param offset The starting index in `data` from which to calculate the encoded size of the `int128`.
-	/// @return The number of bytes that the `int128` would occupy when SCALE-encoded.
-    function encodedSizeAt(bytes memory data, uint256 offset) internal pure returns (uint256) {
+    /// @param data The byte sequence containing the encoded `int128`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `int128`.
+    /// @return The number of bytes that the `int128` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
         return U128.encodedSizeAt(data, offset);
     }
 
@@ -43,10 +46,12 @@ library I128 {
         return int128(U128.decodeAt(data, offset));
     }
 
-	/// @notice Converts an int128 to little-endian bytes16 (two's complement)
+    /// @notice Converts an int128 to little-endian bytes16 (two's complement)
     /// @param value The signed 128-bit integer to convert.
     /// @return result Little-endian byte representation of the input value.
-    function toLittleEndian(int128 value) internal pure returns (bytes16 result) {
+    function toLittleEndian(
+        int128 value
+    ) internal pure returns (bytes16 result) {
         return U128.toLittleEndian(uint128(value));
     }
-}
+}

package/src/Scale/Signed/I16.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.28;
 
-import { U16 } from "../Unsigned/U16.sol";
+import {U16} from "../Unsigned/U16.sol";
 
 /// @title Scale Codec for the `int16` type.
 /// @notice SCALE-compliant encoder/decoder for the `int16` type.
@@ -9,7 +9,7 @@ import { U16 } from "../Unsigned/U16.sol";
 library I16 {
     error OffsetOutOfBounds();
 
-	/// @notice Encodes an `int16` into SCALE format (2-byte two's-complement little-endian).
+    /// @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) {
@@ -17,10 +17,13 @@ library I16 {
     }
 
     /// @notice Returns the number of bytes that a `int16` would occupy when SCALE-encoded.
-	/// @param data The byte sequence containing the encoded `int16`.
-	/// @param offset The starting index in `data` from which to calculate the encoded size of the `int16`.
-	/// @return The number of bytes that the `int16` would occupy when SCALE-encoded.
-    function encodedSizeAt(bytes memory data, uint256 offset) internal pure returns (uint256) {
+    /// @param data The byte sequence containing the encoded `int16`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `int16`.
+    /// @return The number of bytes that the `int16` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
         return U16.encodedSizeAt(data, offset);
     }
 
@@ -43,10 +46,10 @@ library I16 {
         return int16(U16.decodeAt(data, offset));
     }
 
-	/// @notice Converts an int16 to little-endian bytes2 (two's complement)
+    /// @notice Converts an int16 to little-endian bytes2 (two's complement)
     /// @param value The signed 16-bit integer to convert.
     /// @return result Little-endian byte representation of the input value.
     function toLittleEndian(int16 value) internal pure returns (bytes2 result) {
         return U16.toLittleEndian(uint16(value));
     }
-}
+}

package/src/Scale/Signed/I256.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.28;
 
-import { U256 } from "../Unsigned/U256.sol";
+import {U256} from "../Unsigned/U256.sol";
 
 /// @title Scale Codec for the `int256` type.
 /// @notice SCALE-compliant encoder/decoder for the `int256` type.
@@ -9,7 +9,7 @@ import { U256 } from "../Unsigned/U256.sol";
 library I256 {
     error OffsetOutOfBounds();
 
-	/// @notice Encodes an `int256` into SCALE format (32-byte two's-complement little-endian).
+    /// @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) {
@@ -17,10 +17,13 @@ library I256 {
     }
 
     /// @notice Returns the number of bytes that a `int256` would occupy when SCALE-encoded.
-	/// @param data The byte sequence containing the encoded `int256`.
-	/// @param offset The starting index in `data` from which to calculate the encoded size of the `int256`.
-	/// @return The number of bytes that the `int256` would occupy when SCALE-encoded.
-    function encodedSizeAt(bytes memory data, uint256 offset) internal pure returns (uint256) {
+    /// @param data The byte sequence containing the encoded `int256`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `int256`.
+    /// @return The number of bytes that the `int256` would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
         return U256.encodedSizeAt(data, offset);
     }
 
@@ -43,10 +46,12 @@ library I256 {
         return int256(U256.decodeAt(data, offset));
     }
 
-	/// @notice Converts an int256 to little-endian bytes32 (two's complement)
+    /// @notice Converts an int256 to little-endian bytes32 (two's complement)
     /// @param value The signed 256-bit integer to convert.
     /// @return result Little-endian byte representation of the input value.
-    function toLittleEndian(int256 value) internal pure returns (bytes32 result) {
+    function toLittleEndian(
+        int256 value
+    ) internal pure returns (bytes32 result) {
         return U256.toLittleEndian(uint256(value));
     }
-}
+}

package/src/Scale/Signed/I32.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.28;
 
-import { U32 } from "../Unsigned/U32.sol";
+import {U32} from "../Unsigned/U32.sol";
 
 /// @title Scale Codec for the `int32` type.
 /// @notice SCALE-compliant encoder/decoder for the `int32` type.
@@ -9,7 +9,7 @@ import { U32 } from "../Unsigned/U32.sol";
 library I32 {
     error OffsetOutOfBounds();
 
-	/// @notice Encodes an `int32` into SCALE format (4-byte two's-complement little-endian).
+    /// @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) {
@@ -17,10 +17,13 @@ library I32 {
     }
 
     /// @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) {
+    /// @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) {
         return U32.encodedSizeAt(data, offset);
     }
 
@@ -43,10 +46,10 @@ library I32 {
         return int32(U32.decodeAt(data, offset));
     }
 
-	/// @notice Converts an int32 to little-endian bytes4 (two's complement)
+    /// @notice Converts an int32 to little-endian bytes4 (two's complement)
     /// @param value The signed 32-bit integer to convert.
     /// @return result Little-endian byte representation of the input value.
     function toLittleEndian(int32 value) internal pure returns (bytes4 result) {
         return U32.toLittleEndian(uint32(value));
     }
-}
+}