solidity-scale-codec 0.1.0

package/src/Scale/Unsigned/U256.sol

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

package/src/Scale/Unsigned/U32.sol

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

package/src/Scale/Unsigned/U64.sol

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

package/src/Scale/Unsigned/U8.sol

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

package/src/Scale/Unsigned.sol

@@ -0,0 +1,10 @@
+
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20; 
+
+import { U8 } from "./Unsigned/U8.sol"; 
+import { U16 } from "./Unsigned/U16.sol"; 
+import { U32 } from "./Unsigned/U32.sol"; 
+import { U64 } from "./Unsigned/U64.sol"; 
+import { U128 } from "./Unsigned/U128.sol"; 
+import { U256 } from "./Unsigned/U256.sol"; 

package/src/Utils/LittleEndian/LittleEndian.sol

@@ -0,0 +1,354 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+/// @title LittleEndian
+/// @notice Gas-optimized library for converting unsigned integers from big-endian to little-endian
+library LittleEndian {
+    /// @notice Converts a uint8 to little-endian bytes1
+    function toLittleEndianU8(uint8 value) internal pure returns (bytes1) {
+        return bytes1(value);
+    }
+
+    /// @notice Converts an int8 to little-endian bytes1 (two's complement)
+    function toLittleEndianI8(int8 value) internal pure returns (bytes1) {
+        return bytes1(uint8(value));
+    }
+
+    /// @notice Converts a uint16 to little-endian bytes2
+    function toLittleEndianU16(uint16 value) internal pure returns (bytes2) {
+        return bytes2(uint16((value >> 8) | (value << 8)));
+    }
+
+    /// @notice Converts an int16 to little-endian bytes2 (two's complement)
+    function toLittleEndianI16(int16 value) internal pure returns (bytes2) {
+        return toLittleEndianU16(uint16(value));
+    }
+
+    /// @notice Converts a uint32 to little-endian bytes4
+    function toLittleEndianU32(
+        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 Converts an int32 to little-endian bytes4 (two's complement)
+    function toLittleEndianI32(int32 value) internal pure returns (bytes4) {
+        return toLittleEndianU32(uint32(value));
+    }
+
+    /// @notice Converts a uint64 to little-endian bytes8
+    function toLittleEndianU64(
+        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 Converts an int64 to little-endian bytes8 (two's complement)
+    function toLittleEndianI64(int64 value) internal pure returns (bytes8) {
+        return toLittleEndianU64(uint64(value));
+    }
+
+    /// @notice Converts a uint128 to little-endian bytes16
+    function toLittleEndianU128(
+        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 Converts an int128 to little-endian bytes16 (two's complement)
+    function toLittleEndianI128(int128 value) internal pure returns (bytes16) {
+        return toLittleEndianU128(uint128(value));
+    }
+
+    /// @notice Converts a uint256 to little-endian bytes32
+    function toLittleEndianU256(
+        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 Converts an int256 to little-endian bytes32 (two's complement)
+    function toLittleEndianI256(int256 value) internal pure returns (bytes32) {
+        return toLittleEndianU256(uint256(value));
+    }
+
+    /// @notice Converts little-endian bytes1 to uint8
+    function fromLittleEndianU8(bytes1 value) internal pure returns (uint8) {
+        return uint8(value);
+    }
+
+    /// @notice Converts little-endian bytes1 to int8
+    function fromLittleEndianI8(bytes1 value) internal pure returns (int8) {
+        return int8(uint8(value));
+    }
+
+    /// @notice Converts little-endian bytes2 to uint16
+    function fromLittleEndianU16(bytes2 value) internal pure returns (uint16) {
+        return uint16(uint8(value[0])) | (uint16(uint8(value[1])) << 8);
+    }
+
+    /// @notice Converts little-endian bytes2 to int16
+    function fromLittleEndianI16(bytes2 value) internal pure returns (int16) {
+        return int16(fromLittleEndianU16(value));
+    }
+
+    /// @notice Converts little-endian bytes4 to uint32
+    function fromLittleEndianU32(
+        bytes4 value
+    ) internal pure returns (uint32 result) {
+        assembly {
+            let v := shr(224, value)
+            v := or(
+                or(shl(24, and(v, 0xff)), shl(16, and(shr(8, v), 0xff))),
+                or(shl(8, and(shr(16, v), 0xff)), and(shr(24, v), 0xff))
+            )
+            result := v
+        }
+    }
+
+    /// @notice Converts little-endian bytes4 to int32
+    function fromLittleEndianI32(bytes4 value) internal pure returns (int32) {
+        return int32(fromLittleEndianU32(value));
+    }
+
+    /// @notice Converts little-endian bytes8 to uint64
+    function fromLittleEndianU64(
+        bytes8 value
+    ) internal pure returns (uint64 result) {
+        assembly {
+            let v := shr(192, 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 := v
+        }
+    }
+
+    /// @notice Converts little-endian bytes8 to int64
+    function fromLittleEndianI64(bytes8 value) internal pure returns (int64) {
+        return int64(fromLittleEndianU64(value));
+    }
+
+    /// @notice Converts little-endian bytes16 to uint128
+    function fromLittleEndianU128(
+        bytes16 value
+    ) internal pure returns (uint128 result) {
+        assembly {
+            let v := shr(128, 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 := v
+        }
+    }
+
+    /// @notice Converts little-endian bytes16 to int128
+    function fromLittleEndianI128(
+        bytes16 value
+    ) internal pure returns (int128) {
+        return int128(fromLittleEndianU128(value));
+    }
+
+    /// @notice Converts little-endian bytes32 to uint256
+    function fromLittleEndianU256(
+        bytes32 value
+    ) internal pure returns (uint256 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 Converts little-endian bytes32 to int256
+    function fromLittleEndianI256(
+        bytes32 value
+    ) internal pure returns (int256) {
+        return int256(fromLittleEndianU256(value));
+    }
+}