solidity-scale-codec 0.1.0

package/src/Scale/Array/U16Arr.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Compact} from "../Compact/Compact.sol";
+import { U16 } from "../Unsigned.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 U16Arr {
+	using U16 for uint16;
+
+	/// @notice Encodes an `uint16[]` into SCALE format.
+	function encode(uint16[] 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 `uint16[]` from SCALE format.
+	function decode(bytes memory data) 
+		internal pure returns (uint16[] memory arr, uint256 bytesRead) 
+	{
+		return decodeAt(data, 0);
+	}
+
+	/// @notice Decodes an `uint16[]` from SCALE format.
+	function decodeAt(bytes memory data, uint256 offset) 
+		internal pure returns (uint16[] memory arr, uint256 bytesRead) 
+	{
+		(uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
+		uint256 pos = offset + compactBytes;
+		
+		arr = new uint16[](length);
+		for (uint256 i = 0; i < length; i++) {
+			arr[i] = U16.decodeAt(data, pos);
+			pos += 2;
+		}
+		
+		bytesRead = pos - offset;
+	}
+}

package/src/Scale/Array/U256Arr.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Compact} from "../Compact/Compact.sol";
+import { U256 } from "../Unsigned.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 U256Arr {
+	using U256 for uint256;
+
+	/// @notice Encodes an `uint256[]` into SCALE format.
+	function encode(uint256[] 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 `uint256[]` from SCALE format.
+	function decode(bytes memory data) 
+		internal pure returns (uint256[] memory arr, uint256 bytesRead) 
+	{
+		return decodeAt(data, 0);
+	}
+
+	/// @notice Decodes an `uint256[]` from SCALE format.
+	function decodeAt(bytes memory data, uint256 offset) 
+		internal pure returns (uint256[] memory arr, uint256 bytesRead) 
+	{
+		(uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
+		uint256 pos = offset + compactBytes;
+		
+		arr = new uint256[](length);
+		for (uint256 i = 0; i < length; i++) {
+			arr[i] = U256.decodeAt(data, pos);
+			pos += 32;
+		}
+		
+		bytesRead = pos - offset;
+	}
+}

package/src/Scale/Array/U32Arr.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Compact} from "../Compact/Compact.sol";
+import { U32 } from "../Unsigned.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 U32Arr {
+	using U32 for uint32;
+
+	/// @notice Encodes an `uint32[]` into SCALE format.
+	function encode(uint32[] 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 `uint32[]` from SCALE format.
+	function decode(bytes memory data) 
+		internal pure returns (uint32[] memory arr, uint256 bytesRead) 
+	{
+		return decodeAt(data, 0);
+	}
+
+	/// @notice Decodes an `uint32[]` from SCALE format.
+	function decodeAt(bytes memory data, uint256 offset) 
+		internal pure returns (uint32[] memory arr, uint256 bytesRead) 
+	{
+		(uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
+		uint256 pos = offset + compactBytes;
+		
+		arr = new uint32[](length);
+		for (uint256 i = 0; i < length; i++) {
+			arr[i] = U32.decodeAt(data, pos);
+			pos += 4;
+		}
+		
+		bytesRead = pos - offset;
+	}
+}

package/src/Scale/Array/U64Arr.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Compact} from "../Compact/Compact.sol";
+import { U64 } from "../Unsigned.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 U64Arr {
+	using U64 for uint64;
+
+	/// @notice Encodes an `uint64[]` into SCALE format.
+	function encode(uint64[] 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 `uint64[]` from SCALE format.
+	function decode(bytes memory data) 
+		internal pure returns (uint64[] memory arr, uint256 bytesRead) 
+	{
+		return decodeAt(data, 0);
+	}
+
+	/// @notice Decodes an `uint64[]` from SCALE format.
+	function decodeAt(bytes memory data, uint256 offset) 
+		internal pure returns (uint64[] memory arr, uint256 bytesRead) 
+	{
+		(uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
+		uint256 pos = offset + compactBytes;
+		
+		arr = new uint64[](length);
+		for (uint256 i = 0; i < length; i++) {
+			arr[i] = U64.decodeAt(data, pos);
+			pos += 8;
+		}
+		
+		bytesRead = pos - offset;
+	}
+}

package/src/Scale/Array/U8Arr.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Compact} from "../Compact/Compact.sol";
+import { U8 } from "../Unsigned.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 U8Arr {
+	using U8 for uint8;
+
+	/// @notice Encodes an `uint8[]` into SCALE format.
+	function encode(uint8[] 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 `uint8[]` from SCALE format.
+	function decode(bytes memory data) 
+		internal pure returns (uint8[] memory arr, uint256 bytesRead) 
+	{
+		return decodeAt(data, 0);
+	}
+
+	/// @notice Decodes an `uint8[]` from SCALE format.
+	function decodeAt(bytes memory data, uint256 offset) 
+		internal pure returns (uint8[] memory arr, uint256 bytesRead) 
+	{
+		(uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
+		uint256 pos = offset + compactBytes;
+		
+		arr = new uint8[](length);
+		for (uint256 i = 0; i < length; i++) {
+			arr[i] = U8.decodeAt(data, pos);
+			pos += 1;
+		}
+		
+		bytesRead = pos - offset;
+	}
+}

package/src/Scale/Array.sol

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

package/src/Scale/Bool/Bool.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+/// @title Scale Codec for the `bool` type.
+/// @notice SCALE-compliant encoder/decoder for `bool`.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+library Bool {
+    error InvalidLength();
+
+    /// @notice Encodes a `bool` into SCALE format (1-byte).
+    /// @param value The boolean to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(bool value) internal pure returns (bytes memory) {
+        return abi.encodePacked(value ? bytes1(0x01) : bytes1(0x00));
+    }
+
+    /// @notice Decodes SCALE-encoded bytes into a `bool`.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return The decoded boolean.
+    function decode(bytes memory data) internal pure returns (bool) {
+        if (data.length < 1) revert InvalidLength();
+        return data[0] != 0x00;
+    }
+
+    /// @notice Decodes a boolean at the specified offset.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @param offset The byte offset to start decoding from.
+    /// @return value The decoded `bool`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (bool value) {
+        if (data.length < offset + 1) revert InvalidLength();
+        assembly {
+            value := iszero(
+                iszero(and(mload(add(add(data, 32), offset)), 0xFF))
+            )
+        }
+    }
+}

package/src/Scale/Bool.sol

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