solidity-scale-codec 1.0.1 → 2.1.0

package/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 [Unreleased]
 
+### Added
+
+- Missing `GlobalConsensus` junction variant and related helper function in `Junction.sol` and `JunctionCodec.sol`. - [#5592427](https://github.com/LucasGrasso/solidity-scale-codec/commit/5592427)
+
+### Fixed
+
+- Variant checking in `NetworkId`. - [#7e9309d](https://github.com/LucasGrasso/solidity-scale-codec/commit/7e9309d)
+- Decoding of `Index` variant in `BodyId`. - [#75ead59](https://github.com/LucasGrasso/solidity-scale-codec/commit/75ead59)
+- Incorrect encoding/decoding of `GeneralKey` junction variant. - [#4e0f795](https://github.com/LucasGrasso/solidity-scale-codec/commit/4e0f795)
+
+## Version 2.0.0
+
+### Added
+
+- Add `Bytes.sol` to barrel import - [#2dbc1ab](https://github.com/LucasGrasso/solidity-scale-codec/commit/2dbc1ab)
+
+### Changed
+
+- Change all `uint8[]` to `bytes` for better ergonomics and consistency with typical byte handling in Solidity. - [#ab6c226](https://github.com/LucasGrasso/solidity-scale-codec/commit/ab6c226)
+
 ## Version 1.0.1
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solidity-scale-codec",
-  "version": "1.0.1",
+  "version": "2.1.0",
   "description": "Solidity implementation of scale-codec.",
   "keywords": [
     "solidity",

package/src/Scale/Bytes.sol

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.28;
 
+import {Bytes} from "./Bytes/Bytes.sol";
 import {Bytes2} from "./Bytes/Bytes2.sol";
 import {Bytes4} from "./Bytes/Bytes4.sol";
 import {Bytes8} from "./Bytes/Bytes8.sol";

package/src/Xcm/v3/MaybeErrorCode/MaybeErrorCode.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.28;
 
-import {U8Arr} from "../../../Scale/Array.sol";
+import {Bytes} from "../../../Scale/Bytes.sol";
 import {MAX_DISPATCH_ERROR_LEN} from "../Constants.sol";
 
 /// @notice Discriminant for the `MaybeErrorCode` enum.
@@ -25,13 +25,13 @@ struct MaybeErrorCode {
 /// @notice Parameters for the `Error` variant.
 struct ErrorParams {
     /// @custom:property Dispatch error bytes.
-    uint8[] errorBytes;
+    bytes errorBytes;
 }
 
 /// @notice Parameters for the `TruncatedError` variant.
 struct TruncatedErrorParams {
     /// @custom:property Truncated dispatch error bytes.
-    uint8[] errorBytes;
+    bytes errorBytes;
 }
 
 // ============ Factory Functions ============
@@ -52,7 +52,7 @@ function error(ErrorParams memory params) pure returns (MaybeErrorCode memory) {
     return
         MaybeErrorCode({
             variant: MaybeErrorCodeVariant.Error,
-            payload: U8Arr.encode(params.errorBytes)
+            payload: Bytes.encode(params.errorBytes)
         });
 }
 
@@ -67,7 +67,7 @@ function truncatedError(
     return
         MaybeErrorCode({
             variant: MaybeErrorCodeVariant.TruncatedError,
-            payload: U8Arr.encode(params.errorBytes)
+            payload: Bytes.encode(params.errorBytes)
         });
 }
 

package/src/Xcm/v3/MaybeErrorCode/MaybeErrorCodeCodec.sol

@@ -1,8 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.28;
 
-import {U8Arr} from "../../../Scale/Array.sol";
-import {MaybeErrorCode, MaybeErrorCodeVariant} from "./MaybeErrorCode.sol";
+import {Bytes} from "../../../Scale/Bytes.sol";
+import {
+    MaybeErrorCode,
+    MaybeErrorCodeVariant,
+    ErrorParams,
+    TruncatedErrorParams
+} from "./MaybeErrorCode.sol";
 import {BytesUtils} from "../../../Utils/BytesUtils.sol";
 
 /// @title SCALE Codec for XCM v3 `MaybeErrorCode`
@@ -38,7 +43,7 @@ library MaybeErrorCodeCodec {
             variant == uint8(MaybeErrorCodeVariant.Error) ||
             variant == uint8(MaybeErrorCodeVariant.TruncatedError)
         ) {
-            return 1 + U8Arr.encodedSizeAt(data, offset + 1);
+            return 1 + Bytes.encodedSizeAt(data, offset + 1);
         } else {
             revert InvalidMaybeErrorCodeVariant(variant);
         }
@@ -78,16 +83,32 @@ library MaybeErrorCodeCodec {
         bytesRead = size;
     }
 
-    /// @notice Decodes the dispatch error bytes from an `Error` or `TruncatedError` MaybeErrorCode.
-    /// @param me The `MaybeErrorCode` struct to decode. Must be of type `Error` or `TruncatedError`.
-    /// @return errorBytes The decoded dispatch error bytes.
-    function decodeError(
+    /// @notice Extracts the `Error` parameters from a `MaybeErrorCode` struct. Reverts if the variant is not `Error`.
+    /// @param me The `MaybeErrorCode` struct to extract from. Must be of type `Error`.
+    /// @return params An `ErrorParams` struct containing the decoded dispatch error
+    function asError(
         MaybeErrorCode memory me
-    ) internal pure returns (uint8[] memory errorBytes) {
-        if (
-            me.variant != MaybeErrorCodeVariant.Error &&
-            me.variant != MaybeErrorCodeVariant.TruncatedError
-        ) revert InvalidMaybeErrorCodeVariant(uint8(me.variant));
-        (errorBytes, ) = U8Arr.decode(me.payload);
+    ) internal pure returns (ErrorParams memory params) {
+        _assertVariant(me, MaybeErrorCodeVariant.Error);
+        (params.errorBytes, ) = Bytes.decode(me.payload);
+    }
+
+    /// @notice Extracts the `TruncatedError` parameters from a `MaybeErrorCode` struct. Reverts if the variant is not `TruncatedError`.
+    /// @param me The `MaybeErrorCode` struct to extract from. Must be of type `TruncatedError`.
+    /// @return params A `TruncatedErrorParams` struct containing the decoded truncated dispatch error
+    function asTruncatedError(
+        MaybeErrorCode memory me
+    ) internal pure returns (TruncatedErrorParams memory params) {
+        _assertVariant(me, MaybeErrorCodeVariant.TruncatedError);
+        (params.errorBytes, ) = Bytes.decode(me.payload);
+    }
+
+    function _assertVariant(
+        MaybeErrorCode memory me,
+        MaybeErrorCodeVariant expected
+    ) private pure {
+        if (me.variant != expected) {
+            revert InvalidMaybeErrorCodeVariant(uint8(me.variant));
+        }
     }
 }

package/src/Xcm/v5/BodyId/BodyIdCodec.sol

@@ -50,7 +50,7 @@ library BodyIdCodec {
         } else if (variant == BodyIdVariant.Moniker) {
             payloadLength = 4;
         } else if (variant == BodyIdVariant.Index) {
-            payloadLength = 4;
+            payloadLength = Compact.encodedSizeAt(data, offset + 1);
         } else {
             revert InvalidBodyIdVariant(variantValue);
         }

package/src/Xcm/v5/Junction/Junction.sol

@@ -99,6 +99,12 @@ struct GeneralIndexParams {
     uint128 index;
 }
 
+/// @notice Parameters for a `GlobalConsensus` junction.
+struct GlobalConsensusParams {
+    /// @custom:property The `NetworkId` associated with the global consensus, See `NetworkId` struct for details.
+    NetworkId network;
+}
+
 /// @notice A single item in a path to describe the relative location of a consensus system. Each item assumes a pre-existing location as its context and is defined in terms of it.
 struct Junction {
     /// @custom:property variant The type of the junction, determining how to interpret the payload. See `JunctionVariant` enum for possible values.
@@ -203,11 +209,9 @@ function generalIndex(
 function generalKey(
     GeneralKeyParams memory params
 ) pure returns (Junction memory) {
-    if (
-        params.length == 0 ||
-        params.length > 32 ||
-        params.key.length != params.length
-    ) revert InvalidJunctionPayload();
+    if (params.length == 0 || params.length > 32) {
+        revert InvalidJunctionPayload();
+    }
     return
         Junction({
             variant: JunctionVariant.GeneralKey,
@@ -221,6 +225,19 @@ function onlyChild() pure returns (Junction memory) {
     return Junction({variant: JunctionVariant.OnlyChild, payload: ""});
 }
 
+/// @notice Creates a `GlobalConsensus` junction, which represents a global network capable of externalizing its own consensus.
+/// @param params Parameters for the global consensus variant.
+/// @return A `Junction` struct representing the `GlobalConsensus` junction, with the encoded network payload.
+function globalConsensus(
+    GlobalConsensusParams memory params
+) pure returns (Junction memory) {
+    return
+        Junction({
+            variant: JunctionVariant.GlobalConsensus,
+            payload: params.network.encode()
+        });
+}
+
 /// @notice Creates a `Plurality` junction with the specified body ID and body part.
 /// @param params Parameters for the plurality variant.
 /// @return A `Junction` struct representing the `Plurality` junction with the provided parameters.

package/src/Xcm/v5/Junction/JunctionCodec.sol

@@ -20,7 +20,8 @@ import {
     AccountKey20Params,
     GeneralKeyParams,
     PalletInstanceParams,
-    GeneralIndexParams
+    GeneralIndexParams,
+    GlobalConsensusParams
 } from "./Junction.sol";
 import {BytesUtils} from "../../../Utils/BytesUtils.sol";
 import {UnsignedUtils} from "../../../Utils/UnsignedUtils.sol";
@@ -74,12 +75,12 @@ library JunctionCodec {
         } else if (variant == uint8(JunctionVariant.GeneralKey)) {
             if (offset >= data.length) revert InvalidJunctionLength();
             uint8 length = uint8(data[offset]);
-            payloadLength = 1 + length; // 1 byte for the length + the key bytes
-        } else if (
-            variant == uint8(JunctionVariant.OnlyChild) ||
-            variant == uint8(JunctionVariant.GlobalConsensus)
-        ) {
+            if (length == 0 || length > 32) revert InvalidJunctionPayload();
+            payloadLength = 1 + 32; // 1 byte for the length + the fixed key bytes
+        } else if (variant == uint8(JunctionVariant.OnlyChild)) {
             payloadLength = 0;
+        } else if (variant == uint8(JunctionVariant.GlobalConsensus)) {
+            payloadLength = NetworkIdCodec.encodedSizeAt(data, offset);
         } else if (variant == uint8(JunctionVariant.Plurality)) {
             uint256 innerLength = BodyIdCodec.encodedSizeAt(data, offset);
             payloadLength =
@@ -242,6 +243,16 @@ library JunctionCodec {
         );
     }
 
+    /// @notice Decodes a `GlobalConsensus` junction from a given `Junction` struct, extracting the network information.
+    /// @param junction The `Junction` struct to decode, which should represent a `GlobalConsensus` junction.
+    /// @return params A `GlobalConsensusParams` struct containing the decoded
+    function asGlobalConsensus(
+        Junction memory junction
+    ) internal pure returns (GlobalConsensusParams memory params) {
+        _assertVariant(junction, JunctionVariant.GlobalConsensus);
+        (params.network, ) = NetworkIdCodec.decode(junction.payload);
+    }
+
     function _innerNetworkIdSize(
         bytes memory data,
         uint256 offset

package/src/Xcm/v5/NetworkId/NetworkIdCodec.sol

@@ -49,7 +49,13 @@ library NetworkIdCodec {
             payloadLen = 40; // 8 (u64) + 32 (bytes32)
         } else if (variant == uint8(NetworkIdVariant.Ethereum)) {
             payloadLen = Compact.encodedSizeAt(data, offset + 1);
-        } else if (variant < 4) {
+        } else if (
+            variant == uint8(NetworkIdVariant.Polkadot) ||
+            variant == uint8(NetworkIdVariant.Kusama) ||
+            variant == uint8(NetworkIdVariant.BitcoinCore) ||
+            variant == uint8(NetworkIdVariant.BitcoinCash) ||
+            variant == uint8(NetworkIdVariant.PolkadotBulletin)
+        ) {
             payloadLen = 0; // Static variants
         } else {
             // Reserved or unknown types are invalid

package/src/Xcm/v5/PalletInfo/PalletInfo.sol

@@ -6,9 +6,9 @@ struct PalletInfo {
     /// @custom:property The index which identifies the pallet.
     uint32 index;
     /// @custom:property The name of the pallet. Max length is `MAX_PALLET_NAME_LEN`.
-    uint8[] name;
+    bytes name;
     /// @custom:property The module name of the pallet. Max length is `MAX_PALLET_NAME_LEN`.
-    uint8[] moduleName;
+    bytes moduleName;
     /// @custom:property The major version of the crate which implements the pallet.
     uint32 major;
     /// @custom:property The minor version of the crate which implements the pallet.

package/src/Xcm/v5/PalletInfo/PalletInfoCodec.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.28;
 
 import {Compact} from "../../../Scale/Compact.sol";
-import {U8Arr} from "../../../Scale/Array.sol";
+import {Bytes} from "../../../Scale/Bytes.sol";
 import {MAX_PALLET_NAME_LEN} from "../Constants.sol";
 import {PalletInfo} from "./PalletInfo.sol";
 
@@ -27,8 +27,8 @@ library PalletInfoCodec {
         return
             abi.encodePacked(
                 Compact.encode(info.index),
-                U8Arr.encode(info.name),
-                U8Arr.encode(info.moduleName),
+                Bytes.encode(info.name),
+                Bytes.encode(info.moduleName),
                 Compact.encode(info.major),
                 Compact.encode(info.minor),
                 Compact.encode(info.patch)
@@ -46,8 +46,8 @@ library PalletInfoCodec {
         if (data.length < offset + 1) revert InvalidPalletInfoLength();
         uint256 pos = offset;
         pos += Compact.encodedSizeAt(data, pos); // index
-        pos += U8Arr.encodedSizeAt(data, pos); // name
-        pos += U8Arr.encodedSizeAt(data, pos); // moduleName
+        pos += Bytes.encodedSizeAt(data, pos); // name
+        pos += Bytes.encodedSizeAt(data, pos); // moduleName
         pos += Compact.encodedSizeAt(data, pos); // major
         pos += Compact.encodedSizeAt(data, pos); // minor
         pos += Compact.encodedSizeAt(data, pos); // patch
@@ -80,12 +80,12 @@ library PalletInfoCodec {
         (index, read) = Compact.decodeAt(data, pos);
         pos += read;
 
-        uint8[] memory name;
-        (name, read) = U8Arr.decodeAt(data, pos);
+        bytes memory name;
+        (name, read) = Bytes.decodeAt(data, pos);
         pos += read;
 
-        uint8[] memory moduleName;
-        (moduleName, read) = U8Arr.decodeAt(data, pos);
+        bytes memory moduleName;
+        (moduleName, read) = Bytes.decodeAt(data, pos);
         pos += read;
 
         uint256 major;