solidity-scale-codec 0.1.3 → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,25 @@
+## Version 0.2.1
+
+### Added
+
+- Documentation Site - []()
+
+### Changed
+
+- Fix docs in Junctions - [#de668af..e7b8edb](https://github.com/LucasGrasso/solidity-scale-codec/commit/e7b8edbfd6f965c0120cb2572f24e3c8e81c78fe)
+
+## Version 0.2.0
+
+### Added
+
+- Implemented complete XCM v5 support surface with full Instruction model (all variants with Params and factory functions), Instruction/Xcm/VersionedXcm codecs, XCM helper utilities, VersionedXcm harness and cross-fuzz script scaffolding, plus README XCM usage documentation. - [#2](https://github.com/LucasGrasso/solidity-scale-codec/pull/2)
+
+- Added Codecs for Bytes, Address - [#2](https://github.com/LucasGrasso/solidity-scale-codec/pull/2)
+
+### Changed
+
+- Hardened decoding safety and consistency by fixing Transact call length handling, adding/trimming bounds checks at codec boundaries (Response, XcmError, VersionedXcm, Compact, and generated array codecs), updating array codegen template to preserve those checks, and standardizing docs/comments/style across the XCM v5 folder. - [#2](https://github.com/LucasGrasso/solidity-scale-codec/pull/2)
+
+- Fix typos and add `encodedSizeAt` functions to all codecs for better safety and consistency. - [#2](https://github.com/LucasGrasso/solidity-scale-codec/pull/2)
+
+- General code cleanup and refactoring. - [#2](https://github.com/LucasGrasso/solidity-scale-codec/pull/2)

package/DEFINITIONS.md

@@ -0,0 +1,132 @@
+> 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.
+
+# Notation
+
+- Let $\mathbb{{B}}$ be the set of all byte sequences.
+- For $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.
+
+### 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[]` array, which is supported by this library.

package/README.md

@@ -4,6 +4,8 @@
 </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>
 
+📖 **[View Documentation](https://lucasgrasso.github.io/solidity-scale-codec/)** — Documentation site with API reference
+
 ## Description
 
 [Substrate](https://github.com/paritytech/substrate) uses a lightweight and efficient [encoding and decoding program](https://docs.polkadot.com/polkadot-protocol/parachain-basics/data-encoding/#data-encoding) to optimize how data is sent and received over the network. The program used to serialize and deserialize data is called the SCALE codec, with SCALE being an acronym for **S**imple **C**oncatenated **A**ggregate **L**ittle-**E**ndian.
@@ -20,7 +22,7 @@ This library provides a Highly-Modular implementation of SCALE in solidity.
 | `Compact` | A "compact" or general integer encoding is sufficient for encoding large integers (up to 2\*\*536) and is more efficient at encoding most values than the fixed-width version. (Though for single-byte values, the fixed-width integer is never worse.) | `0`     | `0x00`     |
 | `Arrays`  | A collection of same-typed values is encoded, prefixed with a compact encoding of the number of items, followed by each item's encoding concatenated in turn. Currently `[uintN]`,`[intN]`, `[bool]` are supported.                                     | `[1,0]` | `0x080100` |
 
-See the [Definitions](definitions.md) for more details on the encoding of different types.
+See the [Definitions](DEFINITIONS.md) for more details on the encoding of different types.
 
 ## Usage
 
@@ -28,6 +30,100 @@ See the [Definitions](definitions.md) for more details on the encoding of differ
 
 See this [example](https://github.com/LucasGrasso/solidity-scale-codec/blob/main/contracts/examples/Foo.sol).
 
+## About the libraries
+
+### src/LittleEndian
+
+The `LittleEndian` library provides functions to encode and decode unsigned integers in little-endian format.
+
+All libraries here provide the following functions:
+
+```solidity
+function toLittleEndian(uintN value) internal pure returns (bytesM){}
+function fromLittleEndian(
+	bytes memory data,
+	uint256 offset
+) internal pure returns (uintN value) {}
+```
+
+### src/Scale
+
+The `Scale` library provides functions to encode and decode various types in the SCALE format, including booleans, unsigned integers, signed integers, compact integers, and arrays of these types.
+
+- All Codec libraries provide the following encoding functions:
+
+  ```solidity
+  function encode(T value) internal pure returns (bytes memory){}
+  function encodedSizeAt(bytes memory data, uint256 offset) internal pure returns (uint256 size){}
+  ```
+
+- Libraries for fixed length types provide the following functions for encoding:
+
+  ```solidity
+  function decode(bytes memory data) internal pure returns (T value){}
+  function decodeAt(bytes memory data, uint256 offset) internal pure returns (T value){}
+  ```
+
+  > Note: `decode(data)` = `decodeAt(data, 0)`
+
+  Integer libraries also provide Little-Endian encoding functions, using the `LittleEndian` library:
+
+  ```solidity
+  function toLittleEndian(T value) internal pure returns (bytesM){}
+  ```
+
+- Variable length types libraries provide the same encoding functions, but the decoding functions also return the number of bytes read from the input data. This is useful for decoding from a larger byte array where the encoded value is not at the beginning.
+
+  ```solidity
+  function decode(bytes memory data) internal pure returns (T value, uint256 bytesRead){}
+  function decodeAt(bytes memory data, uint256 offset) internal pure returns (T value, uint256 bytesRead){}
+  ```
+
+  > Note: `decode(data)` = `decodeAt(data, 0)`
+
+### src/Xcm
+
+The `Xcm` library contains SCALE-compatible Solidity representations and codecs for XCM types.
+
+Current support includes:
+
+- XCM v5 domain types in `src/Xcm/v5/*` (instructions, locations, assets, responses, errors, weights, and related codecs).
+- A versioned wrapper in `src/Xcm/VersionedXcm/*`.
+
+Implementation notes:
+
+- Enum-like XCM types are represented as structs with a type discriminator plus `bytes payload`.
+- Each type has a codec library with `encode`, `encodedSizeAt`, `decode`, and `decodeAt`.
+- `VersionedXcm` currently supports v5 payloads.
+
+Minimal usage example:
+
+```solidity
+import {Instruction} from "../src/Xcm/v5/Instruction/Instruction.sol";
+import {Xcm, fromInstructions} from "../src/Xcm/v5/Xcm/Xcm.sol";
+import {v5} from "../src/Xcm/VersionedXcm/VersionedXcm.sol";
+import {VersionedXcmCodec} from "../src/Xcm/VersionedXcm/VersionedXcmCodec.sol";
+import {Weight} from "../src/Xcm/v5/Weight/Weight.sol";
+import {WeightCodec} from "../src/Xcm/v5/Weight/WeightCodec.sol";
+
+address constant XCM_PRECOMPILE_ADDRESS = 0x00000000000000000000000000000000000a0000;
+
+contract XcmWeightEstimator {
+  function weighMessage(
+    Instruction[] memory instructions
+  ) external view returns (Weight memory) {
+    Xcm memory xcm = fromInstructions(instructions);
+    (bool success, bytes memory result) = XCM_PRECOMPILE_ADDRESS.staticcall(
+      VersionedXcmCodec.encode(v5(xcm))
+    );
+    require(success, "XCM precompile call failed");
+    (Weight memory weight, ) = WeightCodec.decode(result);
+    return weight;
+  }
+}
+
+```
+
 ### Running Tests
 
 To run all the tests in the project, execute the following command:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solidity-scale-codec",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "Solidity implementation of scale-codec.",
   "keywords": [
     "solidity",
@@ -17,7 +17,11 @@
   },
   "files": [
     "src/**/*.sol",
-    "!src/**/*.t.sol"
+    "!src/**/*.t.sol",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "DEFINITIONS.md"
   ],
   "license": "Apache-2.0",
   "author": "LucasGrasso",
@@ -27,7 +31,12 @@
     "gas-report": "env ENABLE_GAS_REPORT=true npm run test",
     "codegen-signed": "npx hardhat run codegen/signed/generate.ts",
     "codegen-unsigned": "npx hardhat run codegen/unsigned/generate.ts",
-    "codegen-array": "npx hardhat run codegen/array/generate.ts"
+    "codegen-array": "npx hardhat run codegen/array/generate.ts",
+    "codegen-bytes": "npx hardhat run codegen/bytes/generate.ts",
+    "docs:gen": "solidity-docgen",
+    "docs:dev": "npm run docs:gen && vitepress dev docs",
+    "docs:build": "npm run docs:gen && vitepress build docs",
+    "docs:preview": "vitepress preview docs"
   },
   "type": "module",
   "devDependencies": {
@@ -39,6 +48,9 @@
     "prettier": "^3.8.1",
     "prettier-plugin-solidity": "^2.2.1",
     "typescript": "~5.8.0",
-    "viem": "^2.40.3"
+    "viem": "^2.40.3",
+    "vitepress": "^1.6.4",
+    "vue": "^3.4.0",
+    "solidity-doc-generator": "^1.0.4"
   }
 }

package/src/LittleEndian/LittleEndianU128.sol

@@ -7,7 +7,9 @@ library LittleEndianU128 {
     /// @notice Converts a `uint128` to little-endian `bytes16`
     /// @param value The `uint128` value to convert.
     /// @return result The little-endian representation of the input `uint128` as a `bytes16`.
-    function toLE(uint128 value) internal pure returns (bytes16 result) {
+    function toLittleEndian(
+        uint128 value
+    ) internal pure returns (bytes16 result) {
         assembly {
             let v := value
             v := or(
@@ -31,7 +33,7 @@ library LittleEndianU128 {
     /// @param data   Raw byte buffer.
     /// @param offset Byte offset into `data`.
     /// @return value Decoded uint128.
-    function fromLE(
+    function fromLittleEndian(
         bytes memory data,
         uint256 offset
     ) internal pure returns (uint128 value) {

package/src/LittleEndian/LittleEndianU16.sol

@@ -7,7 +7,7 @@ library LittleEndianU16 {
     /// @notice Converts a `uint16` to little-endian `bytes2`
     /// @param value The `uint16` value to convert
     /// @return result The little-endian representation of the input `uint16` as a `bytes2`
-    function toLE(uint16 value) internal pure returns (bytes2) {
+    function toLittleEndian(uint16 value) internal pure returns (bytes2) {
         return bytes2(uint16((value >> 8) | (value << 8)));
     }
 
@@ -15,7 +15,7 @@ library LittleEndianU16 {
     /// @param data   Raw byte buffer.
     /// @param offset Byte offset into `data`.
     /// @return value Decoded uint16.
-    function fromLE(
+    function fromLittleEndian(
         bytes memory data,
         uint256 offset
     ) internal pure returns (uint16 value) {

package/src/LittleEndian/LittleEndianU256.sol

@@ -7,7 +7,9 @@ library LittleEndianU256 {
     /// @notice Converts a `uint256` to little-endian `bytes32`
     /// @param value The `uint256` value to convert.
     /// @return result The little-endian representation of the input `uint256` as a `bytes32`.
-    function toLE(uint256 value) internal pure returns (bytes32 result) {
+    function toLittleEndian(
+        uint256 value
+    ) internal pure returns (bytes32 result) {
         assembly {
             let v := value
             v := or(
@@ -83,7 +85,7 @@ library LittleEndianU256 {
     /// @param data   Raw byte buffer.
     /// @param offset Byte offset into `data`.
     /// @return value Decoded uint256.
-    function fromLE(
+    function fromLittleEndian(
         bytes memory data,
         uint256 offset
     ) internal pure returns (uint256 value) {

package/src/LittleEndian/LittleEndianU32.sol

@@ -7,7 +7,9 @@ library LittleEndianU32 {
     /// @notice Converts a `uint32` to little-endian `bytes4`
     /// @param value The `uint32` value to convert
     /// @return result The little-endian representation of the input `uint32` as a `bytes4`
-    function toLE(uint32 value) internal pure returns (bytes4 result) {
+    function toLittleEndian(
+        uint32 value
+    ) internal pure returns (bytes4 result) {
         assembly {
             let v := or(
                 or(
@@ -24,7 +26,7 @@ library LittleEndianU32 {
     /// @param data   Raw byte buffer.
     /// @param offset Byte offset into `data`.
     /// @return value Decoded uint32.
-    function fromLE(
+    function fromLittleEndian(
         bytes memory data,
         uint256 offset
     ) internal pure returns (uint32 value) {

package/src/LittleEndian/LittleEndianU64.sol

@@ -7,7 +7,9 @@ library LittleEndianU64 {
     /// @notice Converts a `uint64` to little-endian `bytes8`
     /// @param value The `uint64` value to convert.
     /// @return result The little-endian representation of the input `uint64` as a `bytes8`.
-    function toLE(uint64 value) internal pure returns (bytes8 result) {
+    function toLittleEndian(
+        uint64 value
+    ) internal pure returns (bytes8 result) {
         assembly {
             let v := value
             v := or(
@@ -27,7 +29,7 @@ library LittleEndianU64 {
     /// @param data   Raw byte buffer.
     /// @param offset Byte offset into `data`.
     /// @return value Decoded uint64.
-    function fromLE(
+    function fromLittleEndian(
         bytes memory data,
         uint256 offset
     ) internal pure returns (uint64 value) {

package/src/LittleEndian/LittleEndianU8.sol

@@ -7,7 +7,7 @@ library LittleEndianU8 {
     /// @notice Converts a `uint8` to little-endian `bytes1`
     /// @param value The `uint8` value to convert.
     /// @return result The little-endian representation of the input `uint8` as a `bytes1`.
-    function toLE(uint8 value) internal pure returns (bytes1) {
+    function toLittleEndian(uint8 value) internal pure returns (bytes1) {
         return bytes1(value);
     }
 
@@ -15,7 +15,7 @@ library LittleEndianU8 {
     /// @param data   Raw byte buffer.
     /// @param offset Byte offset into `data`.
     /// @return value Decoded uint8.
-    function fromLE(
+    function fromLittleEndian(
         bytes memory data,
         uint256 offset
     ) internal pure returns (uint8 value) {

package/src/Scale/Address/Address.sol

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

package/src/Scale/Address.sol

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

package/src/Scale/Array/BoolArr.sol

@@ -8,7 +8,7 @@ import {Bool} from "../Bool.sol";
 /// @notice SCALE-compliant encoder/decoder for the `bool[]` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library BoolArr {
-    error InvalidBoolArrLenght();
+    error InvalidBoolArrLength();
 
     using Bool for bool;
 
@@ -23,6 +23,20 @@ library BoolArr {
         return result;
     }
 
+    /// @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) {
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 1);
+        if (offset + totalSize > data.length) revert InvalidBoolArrLength();
+        return totalSize;
+    }
+
     /// @notice Decodes an `bool[]` from SCALE format.
     /// @param data The SCALE-encoded byte sequence.
     /// @return arr The decoded array of `bool`.
@@ -45,7 +59,7 @@ library BoolArr {
         (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
         uint256 pos = offset + compactBytes;
 
-        if (pos + (length * 1) > data.length) revert InvalidBoolArrLenght();
+        if (pos + (length * 1) > data.length) revert InvalidBoolArrLength();
 
         arr = new bool[](length);
         for (uint256 i = 0; i < length; ++i) {

package/src/Scale/Array/I128Arr.sol

@@ -8,7 +8,7 @@ import {I128} from "../Signed.sol";
 /// @notice SCALE-compliant encoder/decoder for the `int128[]` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library I128Arr {
-    error InvalidI128ArrLenght();
+    error InvalidI128ArrLength();
 
     using I128 for int128;
 
@@ -23,6 +23,20 @@ library I128Arr {
         return result;
     }
 
+    /// @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) {
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 16);
+        if (offset + totalSize > data.length) revert InvalidI128ArrLength();
+        return totalSize;
+    }
+
     /// @notice Decodes an `int128[]` from SCALE format.
     /// @param data The SCALE-encoded byte sequence.
     /// @return arr The decoded array of `int128`.
@@ -45,7 +59,7 @@ library I128Arr {
         (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
         uint256 pos = offset + compactBytes;
 
-        if (pos + (length * 16) > data.length) revert InvalidI128ArrLenght();
+        if (pos + (length * 16) > data.length) revert InvalidI128ArrLength();
 
         arr = new int128[](length);
         for (uint256 i = 0; i < length; ++i) {

package/src/Scale/Array/I16Arr.sol

@@ -8,7 +8,7 @@ import {I16} from "../Signed.sol";
 /// @notice SCALE-compliant encoder/decoder for the `int16[]` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library I16Arr {
-    error InvalidI16ArrLenght();
+    error InvalidI16ArrLength();
 
     using I16 for int16;
 
@@ -23,6 +23,20 @@ library I16Arr {
         return result;
     }
 
+    /// @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) {
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 2);
+        if (offset + totalSize > data.length) revert InvalidI16ArrLength();
+        return totalSize;
+    }
+
     /// @notice Decodes an `int16[]` from SCALE format.
     /// @param data The SCALE-encoded byte sequence.
     /// @return arr The decoded array of `int16`.
@@ -45,7 +59,7 @@ library I16Arr {
         (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
         uint256 pos = offset + compactBytes;
 
-        if (pos + (length * 2) > data.length) revert InvalidI16ArrLenght();
+        if (pos + (length * 2) > data.length) revert InvalidI16ArrLength();
 
         arr = new int16[](length);
         for (uint256 i = 0; i < length; ++i) {

package/src/Scale/Array/I256Arr.sol

@@ -8,7 +8,7 @@ import {I256} from "../Signed.sol";
 /// @notice SCALE-compliant encoder/decoder for the `int256[]` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library I256Arr {
-    error InvalidI256ArrLenght();
+    error InvalidI256ArrLength();
 
     using I256 for int256;
 
@@ -23,6 +23,20 @@ library I256Arr {
         return result;
     }
 
+    /// @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) {
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 totalSize = prefixSize + (count * 32);
+        if (offset + totalSize > data.length) revert InvalidI256ArrLength();
+        return totalSize;
+    }
+
     /// @notice Decodes an `int256[]` from SCALE format.
     /// @param data The SCALE-encoded byte sequence.
     /// @return arr The decoded array of `int256`.
@@ -45,7 +59,7 @@ library I256Arr {
         (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
         uint256 pos = offset + compactBytes;
 
-        if (pos + (length * 32) > data.length) revert InvalidI256ArrLenght();
+        if (pos + (length * 32) > data.length) revert InvalidI256ArrLength();
 
         arr = new int256[](length);
         for (uint256 i = 0; i < length; ++i) {