solidity-scale-codec 0.1.1 → 0.1.2

package/src/Scale/Array/U256Arr.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 { U256 } from "../Unsigned.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;
-	}
+    error InvalidU256ArrLenght();
+
+    using U256 for uint256;
+
+    /// @notice Encodes an `uint256[]` into SCALE format.
+    /// @param arr The array of `uint256` to encode.
+    /// @return SCALE-encoded byte sequence.
+    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.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return arr The decoded array of `uint256`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decode(
+        bytes memory data
+    ) internal pure returns (uint256[] memory arr, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `uint256[]` 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 `uint256`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    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;
+
+        if (pos + (length * 32) > data.length) revert InvalidU256ArrLenght();
+
+        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

@@ -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 { U32 } from "../Unsigned.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;
-	}
+    error InvalidU32ArrLenght();
+
+    using U32 for uint32;
+
+    /// @notice Encodes an `uint32[]` into SCALE format.
+    /// @param arr The array of `uint32` to encode.
+    /// @return SCALE-encoded byte sequence.
+    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.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return arr The decoded array of `uint32`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decode(
+        bytes memory data
+    ) internal pure returns (uint32[] memory arr, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `uint32[]` 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 `uint32`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    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;
+
+        if (pos + (length * 4) > data.length) revert InvalidU32ArrLenght();
+
+        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

@@ -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 { U64 } from "../Unsigned.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;
-	}
+    error InvalidU64ArrLenght();
+
+    using U64 for uint64;
+
+    /// @notice Encodes an `uint64[]` into SCALE format.
+    /// @param arr The array of `uint64` to encode.
+    /// @return SCALE-encoded byte sequence.
+    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.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return arr The decoded array of `uint64`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decode(
+        bytes memory data
+    ) internal pure returns (uint64[] memory arr, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `uint64[]` 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 `uint64`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    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;
+
+        if (pos + (length * 8) > data.length) revert InvalidU64ArrLenght();
+
+        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

@@ -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 { U8 } from "../Unsigned.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;
-	}
+    error InvalidU8ArrLenght();
+
+    using U8 for uint8;
+
+    /// @notice Encodes an `uint8[]` into SCALE format.
+    /// @param arr The array of `uint8` to encode.
+    /// @return SCALE-encoded byte sequence.
+    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.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return arr The decoded array of `uint8`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decode(
+        bytes memory data
+    ) internal pure returns (uint8[] memory arr, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `uint8[]` 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 `uint8`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    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;
+
+        if (pos + (length * 1) > data.length) revert InvalidU8ArrLenght();
+
+        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

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.20;
+pragma solidity ^0.8.28;
 
 /// @title Scale Codec for the `bool` type.
 /// @notice SCALE-compliant encoder/decoder for `bool`.

package/src/Scale/Bool.sol

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