solidity-scale-codec 0.1.1 → 0.1.2

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

package/src/Scale/Array/I32Arr.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 { I32 } from "../Signed.sol";
+import {I32} from "../Signed.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 I32Arr {
-	using I32 for int32;
-
-	/// @notice Encodes an `int32[]` into SCALE format.
-	function encode(int32[] 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 `int32[]` from SCALE format.
-	function decode(bytes memory data) 
-		internal pure returns (int32[] memory arr, uint256 bytesRead) 
-	{
-		return decodeAt(data, 0);
-	}
-
-	/// @notice Decodes an `int32[]` from SCALE format.
-	function decodeAt(bytes memory data, uint256 offset) 
-		internal pure returns (int32[] memory arr, uint256 bytesRead) 
-	{
-		(uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
-		uint256 pos = offset + compactBytes;
-		
-		arr = new int32[](length);
-		for (uint256 i = 0; i < length; i++) {
-			arr[i] = I32.decodeAt(data, pos);
-			pos += 4;
-		}
-		
-		bytesRead = pos - offset;
-	}
+    error InvalidI32ArrLenght();
+
+    using I32 for int32;
+
+    /// @notice Encodes an `int32[]` into SCALE format.
+    /// @param arr The array of `int32` to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(int32[] 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 `int32[]` from SCALE format.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return arr The decoded array of `int32`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decode(
+        bytes memory data
+    ) internal pure returns (int32[] memory arr, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `int32[]` 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 `int32`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (int32[] memory arr, uint256 bytesRead) {
+        (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
+        uint256 pos = offset + compactBytes;
+
+        if (pos + (length * 4) > data.length) revert InvalidI32ArrLenght();
+
+        arr = new int32[](length);
+        for (uint256 i = 0; i < length; ++i) {
+            arr[i] = I32.decodeAt(data, pos);
+            pos += 4;
+        }
+
+        bytesRead = pos - offset;
+    }
 }

package/src/Scale/Array/I64Arr.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 { I64 } from "../Signed.sol";
+import {I64} from "../Signed.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 I64Arr {
-	using I64 for int64;
-
-	/// @notice Encodes an `int64[]` into SCALE format.
-	function encode(int64[] 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 `int64[]` from SCALE format.
-	function decode(bytes memory data) 
-		internal pure returns (int64[] memory arr, uint256 bytesRead) 
-	{
-		return decodeAt(data, 0);
-	}
-
-	/// @notice Decodes an `int64[]` from SCALE format.
-	function decodeAt(bytes memory data, uint256 offset) 
-		internal pure returns (int64[] memory arr, uint256 bytesRead) 
-	{
-		(uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
-		uint256 pos = offset + compactBytes;
-		
-		arr = new int64[](length);
-		for (uint256 i = 0; i < length; i++) {
-			arr[i] = I64.decodeAt(data, pos);
-			pos += 8;
-		}
-		
-		bytesRead = pos - offset;
-	}
+    error InvalidI64ArrLenght();
+
+    using I64 for int64;
+
+    /// @notice Encodes an `int64[]` into SCALE format.
+    /// @param arr The array of `int64` to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(int64[] 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 `int64[]` from SCALE format.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return arr The decoded array of `int64`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decode(
+        bytes memory data
+    ) internal pure returns (int64[] memory arr, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `int64[]` 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 `int64`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (int64[] memory arr, uint256 bytesRead) {
+        (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
+        uint256 pos = offset + compactBytes;
+
+        if (pos + (length * 8) > data.length) revert InvalidI64ArrLenght();
+
+        arr = new int64[](length);
+        for (uint256 i = 0; i < length; ++i) {
+            arr[i] = I64.decodeAt(data, pos);
+            pos += 8;
+        }
+
+        bytesRead = pos - offset;
+    }
 }

package/src/Scale/Array/I8Arr.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 { I8 } from "../Signed.sol";
+import {I8} from "../Signed.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 I8Arr {
-	using I8 for int8;
-
-	/// @notice Encodes an `int8[]` into SCALE format.
-	function encode(int8[] 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 `int8[]` from SCALE format.
-	function decode(bytes memory data) 
-		internal pure returns (int8[] memory arr, uint256 bytesRead) 
-	{
-		return decodeAt(data, 0);
-	}
-
-	/// @notice Decodes an `int8[]` from SCALE format.
-	function decodeAt(bytes memory data, uint256 offset) 
-		internal pure returns (int8[] memory arr, uint256 bytesRead) 
-	{
-		(uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
-		uint256 pos = offset + compactBytes;
-		
-		arr = new int8[](length);
-		for (uint256 i = 0; i < length; i++) {
-			arr[i] = I8.decodeAt(data, pos);
-			pos += 1;
-		}
-		
-		bytesRead = pos - offset;
-	}
+    error InvalidI8ArrLenght();
+
+    using I8 for int8;
+
+    /// @notice Encodes an `int8[]` into SCALE format.
+    /// @param arr The array of `int8` to encode.
+    /// @return SCALE-encoded byte sequence.
+    function encode(int8[] 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 `int8[]` from SCALE format.
+    /// @param data The SCALE-encoded byte sequence.
+    /// @return arr The decoded array of `int8`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decode(
+        bytes memory data
+    ) internal pure returns (int8[] memory arr, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `int8[]` 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 `int8`.
+    /// @return bytesRead The total number of bytes read during decoding.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (int8[] memory arr, uint256 bytesRead) {
+        (uint256 length, uint256 compactBytes) = Compact.decodeAt(data, offset);
+        uint256 pos = offset + compactBytes;
+
+        if (pos + (length * 1) > data.length) revert InvalidI8ArrLenght();
+
+        arr = new int8[](length);
+        for (uint256 i = 0; i < length; ++i) {
+            arr[i] = I8.decodeAt(data, pos);
+            pos += 1;
+        }
+
+        bytesRead = pos - offset;
+    }
 }

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

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