solidity-scale-codec 0.1.1 → 0.1.2

package/src/Scale/Signed/I16.sol

@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
+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.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library I16 {
-	/// @notice Encodes an `int16` into SCALE format (2-byte two's-complement little-endian).
+    error OffsetOutOfBounds();
+
+    /// @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) {
@@ -29,11 +31,14 @@ library I16 {
         bytes memory data,
         uint256 offset
     ) internal pure returns (int16 value) {
+        // Safety Check is done in the unsigned decoder.
         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,13 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
+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.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library I256 {
-	/// @notice Encodes an `int256` into SCALE format (32-byte two's-complement little-endian).
+    error OffsetOutOfBounds();
+
+    /// @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) {
@@ -29,11 +31,16 @@ library I256 {
         bytes memory data,
         uint256 offset
     ) internal pure returns (int256 value) {
+        // Safety Check is done in the unsigned decoder.
         return int256(U256.decodeAt(data, offset));
     }
 
-	/// @notice Converts an int256 to little-endian bytes32 (two's complement)
-    function toLittleEndian(int256 value) internal pure returns (bytes32 result) {
+    /// @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) {
         return U256.toLittleEndian(uint256(value));
     }
-}
+}

package/src/Scale/Signed/I32.sol

@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
+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.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library I32 {
-	/// @notice Encodes an `int32` into SCALE format (4-byte two's-complement little-endian).
+    error OffsetOutOfBounds();
+
+    /// @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) {
@@ -29,11 +31,14 @@ library I32 {
         bytes memory data,
         uint256 offset
     ) internal pure returns (int32 value) {
+        // Safety Check is done in the unsigned decoder.
         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));
     }
-}
+}

package/src/Scale/Signed/I64.sol

@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.28;
 
-import { U64 } from "../Unsigned/U64.sol";
+import {U64} from "../Unsigned/U64.sol";
 
 /// @title Scale Codec for the `int64` type.
 /// @notice SCALE-compliant encoder/decoder for the `int64` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library I64 {
-	/// @notice Encodes an `int64` into SCALE format (8-byte two's-complement little-endian).
+    error OffsetOutOfBounds();
+
+    /// @notice Encodes an `int64` into SCALE format (8-byte two's-complement little-endian).
     /// @param value The signed 64-bit integer to encode.
     /// @return SCALE-encoded byte sequence.
     function encode(int64 value) internal pure returns (bytes memory) {
@@ -29,11 +31,14 @@ library I64 {
         bytes memory data,
         uint256 offset
     ) internal pure returns (int64 value) {
+        // Safety Check is done in the unsigned decoder.
         return int64(U64.decodeAt(data, offset));
     }
 
-	/// @notice Converts an int64 to little-endian bytes8 (two's complement)
+    /// @notice Converts an int64 to little-endian bytes8 (two's complement)
+    /// @param value The signed 64-bit integer to convert.
+    /// @return result Little-endian byte representation of the input value.
     function toLittleEndian(int64 value) internal pure returns (bytes8 result) {
         return U64.toLittleEndian(uint64(value));
     }
-}
+}

package/src/Scale/Signed/I8.sol

@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.28;
 
-import { U8 } from "../Unsigned/U8.sol";
+import {U8} from "../Unsigned/U8.sol";
 
 /// @title Scale Codec for the `int8` type.
 /// @notice SCALE-compliant encoder/decoder for the `int8` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library I8 {
-	/// @notice Encodes an `int8` into SCALE format (1-byte two's-complement little-endian).
+    error OffsetOutOfBounds();
+
+    /// @notice Encodes an `int8` into SCALE format (1-byte two's-complement little-endian).
     /// @param value The signed 8-bit integer to encode.
     /// @return SCALE-encoded byte sequence.
     function encode(int8 value) internal pure returns (bytes memory) {
@@ -29,11 +31,14 @@ library I8 {
         bytes memory data,
         uint256 offset
     ) internal pure returns (int8 value) {
+        // Safety Check is done in the unsigned decoder.
         return int8(U8.decodeAt(data, offset));
     }
 
-	/// @notice Converts an int8 to little-endian bytes1 (two's complement)
+    /// @notice Converts an int8 to little-endian bytes1 (two's complement)
+    /// @param value The signed 8-bit integer to convert.
+    /// @return result Little-endian byte representation of the input value.
     function toLittleEndian(int8 value) internal pure returns (bytes1 result) {
         return U8.toLittleEndian(uint8(value));
     }
-}
+}

package/src/Scale/Signed.sol

@@ -1,10 +1,9 @@
-
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20; 
+pragma solidity ^0.8.28;
 
-import { I8 } from "./Signed/I8.sol"; 
-import { I16 } from "./Signed/I16.sol"; 
-import { I32 } from "./Signed/I32.sol"; 
-import { I64 } from "./Signed/I64.sol"; 
-import { I128 } from "./Signed/I128.sol"; 
-import { I256 } from "./Signed/I256.sol"; 
+import {I8} from "./Signed/I8.sol";
+import {I16} from "./Signed/I16.sol";
+import {I32} from "./Signed/I32.sol";
+import {I64} from "./Signed/I64.sol";
+import {I128} from "./Signed/I128.sol";
+import {I256} from "./Signed/I256.sol";

package/src/Scale/Unsigned/U128.sol

@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.28;
+
+import {LittleEndianU128} from "../../LittleEndian/LittleEndianU128.sol";
 
 /// @title Scale Codec for the `uint128` type.
 /// @notice SCALE-compliant encoder/decoder for the `uint128` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library U128 {
-	error InvalidU128Length();
+    error InvalidU128Length();
 
-	/// @notice Encodes an `uint128` into SCALE format (16-byte little-endian).
+    /// @notice Encodes an `uint128` into SCALE format (16-byte little-endian).
     /// @param value The unsigned 128-bit integer to encode.
     /// @return SCALE-encoded byte sequence.
     function encode(uint128 value) internal pure returns (bytes memory) {
@@ -30,11 +32,15 @@ library U128 {
         uint256 offset
     ) internal pure returns (uint128 value) {
         if (data.length < offset + 16) revert InvalidU128Length();
-        assembly { let ptr := add(add(data, 32), offset) value := 0 for { let i := 0 } lt(i, 16) { i := add(i, 1) } { let b := and(mload(add(ptr, i)), 0xFF) value := or(value, shl(mul(i, 8), b)) } }
+        return LittleEndianU128.fromLE(data, offset);
     }
 
-	/// @notice Converts an `uint128` to little-endian bytes16
-	function toLittleEndian(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 `uint128` to little-endian bytes16
+    /// @param value The unsigned 128-bit integer to convert.
+    /// @return result Little-endian byte representation of the input value.
+    function toLittleEndian(
+        uint128 value
+    ) internal pure returns (bytes16 result) {
+        return LittleEndianU128.toLE(value);
+    }
+}

package/src/Scale/Unsigned/U16.sol

@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.28;
+
+import {LittleEndianU16} from "../../LittleEndian/LittleEndianU16.sol";
 
 /// @title Scale Codec for the `uint16` type.
 /// @notice SCALE-compliant encoder/decoder for the `uint16` type.
 /// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
 library U16 {
-	error InvalidU16Length();
+    error InvalidU16Length();
 
-	/// @notice Encodes an `uint16` into SCALE format (2-byte little-endian).
+    /// @notice Encodes an `uint16` into SCALE format (2-byte little-endian).
     /// @param value The unsigned 16-bit integer to encode.
     /// @return SCALE-encoded byte sequence.
     function encode(uint16 value) internal pure returns (bytes memory) {
@@ -30,11 +32,15 @@ library U16 {
         uint256 offset
     ) internal pure returns (uint16 value) {
         if (data.length < offset + 2) revert InvalidU16Length();
-        assembly { let ptr := add(add(data, 32), offset) let b0 := and(mload(ptr), 0xFF) let b1 := and(mload(add(ptr, 1)), 0xFF) value := or(b0, shl(8, b1)) }
+        return LittleEndianU16.fromLE(data, offset);
     }
 
-	/// @notice Converts an `uint16` to little-endian bytes2
-	function toLittleEndian(uint16 value) internal pure returns (bytes2 result) {
-		return bytes2(uint16((value >> 8) | (value << 8)));
-	}
-}
+    /// @notice Converts an `uint16` to little-endian bytes2
+    /// @param value The unsigned 16-bit integer to convert.
+    /// @return result Little-endian byte representation of the input value.
+    function toLittleEndian(
+        uint16 value
+    ) internal pure returns (bytes2 result) {
+        return LittleEndianU16.toLE(value);
+    }
+}

package/src/Scale/Unsigned/U256.sol

@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.28;
+
+import {LittleEndianU256} from "../../LittleEndian/LittleEndianU256.sol";
 
 /// @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();
+    error InvalidU256Length();
 
-	/// @notice Encodes an `uint256` into SCALE format (32-byte little-endian).
+    /// @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) {
@@ -30,11 +32,15 @@ library U256 {
         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)) } }
+        return LittleEndianU256.fromLE(data, offset);
     }
 
-	/// @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 }
-	}
-}
+    /// @notice Converts an `uint256` to little-endian bytes32
+    /// @param value The unsigned 256-bit integer to convert.
+    /// @return result Little-endian byte representation of the input value.
+    function toLittleEndian(
+        uint256 value
+    ) internal pure returns (bytes32 result) {
+        return LittleEndianU256.toLE(value);
+    }
+}

package/src/Scale/Unsigned/U32.sol

@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.28;
+
+import {LittleEndianU32} from "../../LittleEndian/LittleEndianU32.sol";
 
 /// @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();
+    error InvalidU32Length();
 
-	/// @notice Encodes an `uint32` into SCALE format (4-byte little-endian).
+    /// @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) {
@@ -30,11 +32,15 @@ library U32 {
         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))) }
+        return LittleEndianU32.fromLE(data, offset);
     }
 
-	/// @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) }
-	}
-}
+    /// @notice Converts an `uint32` to little-endian bytes4
+    /// @param value The unsigned 32-bit integer to convert.
+    /// @return result Little-endian byte representation of the input value.
+    function toLittleEndian(
+        uint32 value
+    ) internal pure returns (bytes4 result) {
+        return LittleEndianU32.toLE(value);
+    }
+}

package/src/Scale/Unsigned/U64.sol

@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.28;
+
+import {LittleEndianU64} from "../../LittleEndian/LittleEndianU64.sol";
 
 /// @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();
+    error InvalidU64Length();
 
-	/// @notice Encodes an `uint64` into SCALE format (8-byte little-endian).
+    /// @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) {
@@ -30,11 +32,15 @@ library U64 {
         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)) } }
+        return LittleEndianU64.fromLE(data, offset);
     }
 
-	/// @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) }
-	}
-}
+    /// @notice Converts an `uint64` to little-endian bytes8
+    /// @param value The unsigned 64-bit integer to convert.
+    /// @return result Little-endian byte representation of the input value.
+    function toLittleEndian(
+        uint64 value
+    ) internal pure returns (bytes8 result) {
+        return LittleEndianU64.toLE(value);
+    }
+}

package/src/Scale/Unsigned/U8.sol

@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.28;
+
+import {LittleEndianU8} from "../../LittleEndian/LittleEndianU8.sol";
 
 /// @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();
+    error InvalidU8Length();
 
-	/// @notice Encodes an `uint8` into SCALE format (1-byte little-endian).
+    /// @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) {
@@ -30,11 +32,13 @@ library U8 {
         uint256 offset
     ) internal pure returns (uint8 value) {
         if (data.length < offset + 1) revert InvalidU8Length();
-        assembly { value := and(mload(add(add(data, 32), offset)), 0xFF) }
+        return LittleEndianU8.fromLE(data, offset);
     }
 
-	/// @notice Converts an `uint8` to little-endian bytes1
-	function toLittleEndian(uint8 value) internal pure returns (bytes1 result) {
-		return bytes1(value);
-	}
-}
+    /// @notice Converts an `uint8` to little-endian bytes1
+    /// @param value The unsigned 8-bit integer to convert.
+    /// @return result Little-endian byte representation of the input value.
+    function toLittleEndian(uint8 value) internal pure returns (bytes1 result) {
+        return LittleEndianU8.toLE(value);
+    }
+}

package/src/Scale/Unsigned.sol

@@ -1,10 +1,9 @@
-
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20; 
+pragma solidity ^0.8.28;
 
-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"; 
+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";