solidity-scale-codec 0.1.1 → 0.1.2

package/README.md

@@ -20,6 +20,8 @@ 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.
+
 ## Usage
 
 ## Encode Structs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solidity-scale-codec",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Solidity implementation of scale-codec.",
   "keywords": [
     "solidity",
@@ -36,6 +36,8 @@
     "@types/node": "^22.19.1",
     "forge-std": "github:foundry-rs/forge-std#v1.9.4",
     "hardhat": "^3.0.15",
+    "prettier": "^3.8.1",
+    "prettier-plugin-solidity": "^2.2.1",
     "typescript": "~5.8.0",
     "viem": "^2.40.3"
   }

package/src/LittleEndian/LittleEndianU128.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+/// @title LittleEndianU128
+/// @notice Gas-optimized library for converting U128 from big-endian to little-endian
+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) {
+        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)
+        }
+    }
+
+    /// @notice Reads a uint128 from `data` at `offset` (little-endian, 16 bytes).
+    /// @param data   Raw byte buffer.
+    /// @param offset Byte offset into `data`.
+    /// @return value Decoded uint128.
+    function fromLE(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint128 value) {
+        assembly {
+            let ptr := add(add(data, 32), offset)
+            for {
+                let i := 0
+            } lt(i, 16) {
+                i := add(i, 1)
+            } {
+                value := or(value, shl(mul(i, 8), shr(248, mload(add(ptr, i)))))
+            }
+        }
+    }
+}

package/src/LittleEndian/LittleEndianU16.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+/// @title LittleEndianU16
+/// @notice Gas-optimized library for converting U16 from big-endian to little-endian
+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) {
+        return bytes2(uint16((value >> 8) | (value << 8)));
+    }
+
+    /// @notice Reads a uint16 from `data` at `offset` (little-endian, 2 bytes).
+    /// @param data   Raw byte buffer.
+    /// @param offset Byte offset into `data`.
+    /// @return value Decoded uint16.
+    function fromLE(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint16 value) {
+        assembly {
+            let ptr := add(add(data, 32), offset)
+            let b0 := shr(248, mload(ptr))
+            let b1 := shr(248, mload(add(ptr, 1)))
+            value := or(b0, shl(8, b1))
+        }
+    }
+}

package/src/LittleEndian/LittleEndianU256.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+/// @title LittleEndianU256
+/// @notice Gas-optimized library for converting U256 from big-endian to little-endian
+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) {
+        assembly {
+            let v := value
+            v := or(
+                shl(
+                    8,
+                    and(
+                        v,
+                        0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF
+                    )
+                ),
+                shr(
+                    8,
+                    and(
+                        v,
+                        0xFF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00
+                    )
+                )
+            )
+            v := or(
+                shl(
+                    16,
+                    and(
+                        v,
+                        0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF
+                    )
+                ),
+                shr(
+                    16,
+                    and(
+                        v,
+                        0xFFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000
+                    )
+                )
+            )
+            v := or(
+                shl(
+                    32,
+                    and(
+                        v,
+                        0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF
+                    )
+                ),
+                shr(
+                    32,
+                    and(
+                        v,
+                        0xFFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000
+                    )
+                )
+            )
+            v := or(
+                shl(
+                    64,
+                    and(
+                        v,
+                        0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF
+                    )
+                ),
+                shr(
+                    64,
+                    and(
+                        v,
+                        0xFFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF0000000000000000
+                    )
+                )
+            )
+            v := or(shl(128, v), shr(128, v))
+            result := v
+        }
+    }
+
+    /// @notice Reads a uint256 from `data` at `offset` (little-endian, 32 bytes).
+    /// @param data   Raw byte buffer.
+    /// @param offset Byte offset into `data`.
+    /// @return value Decoded uint256.
+    function fromLE(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256 value) {
+        assembly {
+            let ptr := add(add(data, 32), offset)
+            for {
+                let i := 0
+            } lt(i, 32) {
+                i := add(i, 1)
+            } {
+                value := or(value, shl(mul(i, 8), shr(248, mload(add(ptr, i)))))
+            }
+        }
+    }
+}

package/src/LittleEndian/LittleEndianU32.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+/// @title LittleEndianU32
+/// @notice Gas-optimized library for converting U32 from big-endian to little-endian
+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) {
+        assembly {
+            let v := or(
+                or(
+                    shl(24, and(value, 0xff)),
+                    shl(16, and(shr(8, value), 0xff))
+                ),
+                or(shl(8, and(shr(16, value), 0xff)), and(shr(24, value), 0xff))
+            )
+            result := shl(224, v) // Shift to bytes4 position (left-align in 256-bit word)
+        }
+    }
+
+    /// @notice Reads a uint32 from `data` at `offset` (little-endian, 4 bytes).
+    /// @param data   Raw byte buffer.
+    /// @param offset Byte offset into `data`.
+    /// @return value Decoded uint32.
+    function fromLE(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint32 value) {
+        assembly {
+            let ptr := add(add(data, 32), offset)
+            for {
+                let i := 0
+            } lt(i, 4) {
+                i := add(i, 1)
+            } {
+                value := or(value, shl(mul(i, 8), shr(248, mload(add(ptr, i)))))
+            }
+        }
+    }
+}

package/src/LittleEndian/LittleEndianU64.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+/// @title LittleEndianU64
+/// @notice Gas-optimized library for converting U64 from big-endian to little-endian
+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) {
+        assembly {
+            let v := value
+            v := or(
+                shl(8, and(v, 0x00FF00FF00FF00FF)),
+                shr(8, and(v, 0xFF00FF00FF00FF00))
+            )
+            v := or(
+                shl(16, and(v, 0x0000FFFF0000FFFF)),
+                shr(16, and(v, 0xFFFF0000FFFF0000))
+            )
+            v := or(shl(32, v), shr(32, v))
+            result := shl(192, v)
+        }
+    }
+
+    /// @notice Reads a uint64 from `data` at `offset` (little-endian, 8 bytes).
+    /// @param data   Raw byte buffer.
+    /// @param offset Byte offset into `data`.
+    /// @return value Decoded uint64.
+    function fromLE(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint64 value) {
+        assembly {
+            let ptr := add(add(data, 32), offset)
+            for {
+                let i := 0
+            } lt(i, 8) {
+                i := add(i, 1)
+            } {
+                value := or(value, shl(mul(i, 8), shr(248, mload(add(ptr, i)))))
+            }
+        }
+    }
+}

package/src/LittleEndian/LittleEndianU8.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+/// @title LittleEndianU8
+/// @notice Gas-optimized library for converting U8 from big-endian to little-endian
+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) {
+        return bytes1(value);
+    }
+
+    /// @notice Reads a uint8 from `data` at `offset`.
+    /// @param data   Raw byte buffer.
+    /// @param offset Byte offset into `data`.
+    /// @return value Decoded uint8.
+    function fromLE(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint8 value) {
+        assembly {
+            value := shr(248, mload(add(add(data, 32), offset)))
+        }
+    }
+}

package/src/Scale/Array/BoolArr.sol

@@ -1,44 +1,58 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.28;
 
 import {Compact} from "../Compact/Compact.sol";
-import { Bool } from "../Bool.sol";
+import {Bool} from "../Bool.sol";
 
 /// @title Scale Codec for the `bool[]` type.
 /// @notice SCALE-compliant encoder/decoder for the `bool[]` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library BoolArr {
-	using Bool for bool;
-
-	/// @notice Encodes an `bool[]` into SCALE format.
-	function encode(bool[] memory arr) internal pure returns (bytes memory) {
-		bytes memory result = Compact.encode(arr.length);
-		for (uint256 i = 0; i < arr.length; i++) {
-			result = bytes.concat(result, arr[i].encode());
-		}
-		return result;
-	}
-
-	/// @notice Decodes an `bool[]` from SCALE format.
-	function decode(bytes memory data) 
-		internal pure returns (bool[] memory arr, uint256 bytesRead) 
-	{
-		return decodeAt(data, 0);
-	}
-
-	/// @notice Decodes an `bool[]` from SCALE format.
-	function decodeAt(bytes memory data, uint256 offset) 
-		internal pure returns (bool[] memory arr, uint256 bytesRead) 
-	{
-		(uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
-		uint256 pos = offset + compactBytes;
-		
-		arr = new bool[](length);
-		for (uint256 i = 0; i < length; i++) {
-			arr[i] = Bool.decodeAt(data, pos);
-			pos += 1;
-		}
-		
-		bytesRead = pos - offset;
-	}
+    error InvalidBoolArrLenght();
+
+    using Bool for bool;
+
+    /// @notice Encodes an `bool[]` into SCALE format.
+    /// @param arr The array of `bool` to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(bool[] memory arr) internal pure returns (bytes memory) {
+        bytes memory result = Compact.encode(arr.length);
+        for (uint256 i = 0; i < arr.length; ++i) {
+            result = bytes.concat(result, arr[i].encode());
+        }
+        return result;
+    }
+
+    /// @notice Decodes an `bool[]` from SCALE format.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return arr The decoded array of `bool`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decode(
+        bytes memory data
+    ) internal pure returns (bool[] memory arr, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `bool[]` from SCALE format at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return arr The decoded array of `bool`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (bool[] memory arr, uint256 bytesRead) {
+        (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
+        uint256 pos = offset + compactBytes;
+
+        if (pos + (length * 1) > data.length) revert InvalidBoolArrLenght();
+
+        arr = new bool[](length);
+        for (uint256 i = 0; i < length; ++i) {
+            arr[i] = Bool.decodeAt(data, pos);
+            pos += 1;
+        }
+
+        bytesRead = pos - offset;
+    }
 }

package/src/Scale/Array/I128Arr.sol

@@ -1,44 +1,58 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.28;
 
 import {Compact} from "../Compact/Compact.sol";
-import { I128 } from "../Signed.sol";
+import {I128} from "../Signed.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 I128Arr {
-	using I128 for int128;
-
-	/// @notice Encodes an `int128[]` into SCALE format.
-	function encode(int128[] memory arr) internal pure returns (bytes memory) {
-		bytes memory result = Compact.encode(arr.length);
-		for (uint256 i = 0; i < arr.length; i++) {
-			result = bytes.concat(result, arr[i].encode());
-		}
-		return result;
-	}
-
-	/// @notice Decodes an `int128[]` from SCALE format.
-	function decode(bytes memory data) 
-		internal pure returns (int128[] memory arr, uint256 bytesRead) 
-	{
-		return decodeAt(data, 0);
-	}
-
-	/// @notice Decodes an `int128[]` from SCALE format.
-	function decodeAt(bytes memory data, uint256 offset) 
-		internal pure returns (int128[] memory arr, uint256 bytesRead) 
-	{
-		(uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
-		uint256 pos = offset + compactBytes;
-		
-		arr = new int128[](length);
-		for (uint256 i = 0; i < length; i++) {
-			arr[i] = I128.decodeAt(data, pos);
-			pos += 16;
-		}
-		
-		bytesRead = pos - offset;
-	}
+    error InvalidI128ArrLenght();
+
+    using I128 for int128;
+
+    /// @notice Encodes an `int128[]` into SCALE format.
+    /// @param arr The array of `int128` to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(int128[] memory arr) internal pure returns (bytes memory) {
+        bytes memory result = Compact.encode(arr.length);
+        for (uint256 i = 0; i < arr.length; ++i) {
+            result = bytes.concat(result, arr[i].encode());
+        }
+        return result;
+    }
+
+    /// @notice Decodes an `int128[]` from SCALE format.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return arr The decoded array of `int128`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decode(
+        bytes memory data
+    ) internal pure returns (int128[] memory arr, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `int128[]` from SCALE format at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return arr The decoded array of `int128`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (int128[] memory arr, uint256 bytesRead) {
+        (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
+        uint256 pos = offset + compactBytes;
+
+        if (pos + (length * 16) > data.length) revert InvalidI128ArrLenght();
+
+        arr = new int128[](length);
+        for (uint256 i = 0; i < length; ++i) {
+            arr[i] = I128.decodeAt(data, pos);
+            pos += 16;
+        }
+
+        bytesRead = pos - offset;
+    }
 }

package/src/Scale/Array/I16Arr.sol

@@ -1,44 +1,58 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.28;
 
 import {Compact} from "../Compact/Compact.sol";
-import { I16 } from "../Signed.sol";
+import {I16} from "../Signed.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 I16Arr {
-	using I16 for int16;
-
-	/// @notice Encodes an `int16[]` into SCALE format.
-	function encode(int16[] memory arr) internal pure returns (bytes memory) {
-		bytes memory result = Compact.encode(arr.length);
-		for (uint256 i = 0; i < arr.length; i++) {
-			result = bytes.concat(result, arr[i].encode());
-		}
-		return result;
-	}
-
-	/// @notice Decodes an `int16[]` from SCALE format.
-	function decode(bytes memory data) 
-		internal pure returns (int16[] memory arr, uint256 bytesRead) 
-	{
-		return decodeAt(data, 0);
-	}
-
-	/// @notice Decodes an `int16[]` from SCALE format.
-	function decodeAt(bytes memory data, uint256 offset) 
-		internal pure returns (int16[] memory arr, uint256 bytesRead) 
-	{
-		(uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
-		uint256 pos = offset + compactBytes;
-		
-		arr = new int16[](length);
-		for (uint256 i = 0; i < length; i++) {
-			arr[i] = I16.decodeAt(data, pos);
-			pos += 2;
-		}
-		
-		bytesRead = pos - offset;
-	}
+    error InvalidI16ArrLenght();
+
+    using I16 for int16;
+
+    /// @notice Encodes an `int16[]` into SCALE format.
+    /// @param arr The array of `int16` to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(int16[] memory arr) internal pure returns (bytes memory) {
+        bytes memory result = Compact.encode(arr.length);
+        for (uint256 i = 0; i < arr.length; ++i) {
+            result = bytes.concat(result, arr[i].encode());
+        }
+        return result;
+    }
+
+    /// @notice Decodes an `int16[]` from SCALE format.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return arr The decoded array of `int16`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decode(
+        bytes memory data
+    ) internal pure returns (int16[] memory arr, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `int16[]` from SCALE format at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return arr The decoded array of `int16`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (int16[] memory arr, uint256 bytesRead) {
+        (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
+        uint256 pos = offset + compactBytes;
+
+        if (pos + (length * 2) > data.length) revert InvalidI16ArrLenght();
+
+        arr = new int16[](length);
+        for (uint256 i = 0; i < length; ++i) {
+            arr[i] = I16.decodeAt(data, pos);
+            pos += 2;
+        }
+
+        bytesRead = pos - offset;
+    }
 }