solidity-scale-codec 0.3.4 → 1.0.1

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

@@ -5,7 +5,7 @@ import {Compact} from "../../../Scale/Compact.sol";
 import {LittleEndianU64} from "../../../LittleEndian/LittleEndianU64.sol";
 
 /// @dev Discriminant for the different types of NetworkIds in XCM v5.
-enum NetworkIdType {
+enum NetworkIdVariant {
     /// @custom:variant Network specified by the first 32 bytes of its genesis block.
     ByGenesis,
     /// @custom:variant Network defined by the first 32-bytes of the hash and number of some block it contains.
@@ -52,9 +52,9 @@ struct ByGenesisParams {
 
 /// @dev Notice A global identifier of a data structure existing within consensus.
 struct NetworkId {
-    /// @custom:property The type of network ID, determining how to interpret the payload. See `NetworkIdType` enum for possible values.
-    NetworkIdType nType;
-    /// @custom:property The encoded payload containing the network identifier data, whose structure depends on the `nType`.
+    /// @custom:property The type of network ID, determining how to interpret the payload. See `NetworkIdVariant` enum for possible values.
+    NetworkIdVariant variant;
+    /// @custom:property The encoded payload containing the network identifier data, whose structure depends on the `variant`.
     bytes payload;
 }
 
@@ -70,36 +70,35 @@ function byGenesis(
 ) pure returns (NetworkId memory) {
     return
         NetworkId({
-            nType: NetworkIdType.ByGenesis,
+            variant: NetworkIdVariant.ByGenesis,
             payload: abi.encodePacked(params.genesisHash)
         });
 }
 
 /// @notice Creates a `ByFork` network ID.
-/// @param blockNumber The block number of the fork point.
-/// @param blockHash The 32-byte hash of the block at the fork point.
+/// @param params Parameters for the by-fork variant.
 /// @return A `NetworkId` struct with type `ByFork` and the provided block number and hash encoded in the payload.
-function byFork(
-    uint64 blockNumber,
-    bytes32 blockHash
-) pure returns (NetworkId memory) {
+function byFork(ByForkParams memory params) pure returns (NetworkId memory) {
     return
         NetworkId({
-            nType: NetworkIdType.ByFork,
-            payload: abi.encodePacked(blockNumber.toLittleEndian(), blockHash)
+            variant: NetworkIdVariant.ByFork,
+            payload: abi.encodePacked(
+                params.blockNumber.toLittleEndian(),
+                params.blockHash
+            )
         });
 }
 
 /// @notice Creates a `Polkadot` network ID.
 /// @return A `NetworkId` struct with type `Polkadot` and an empty payload.
 function polkadot() pure returns (NetworkId memory) {
-    return NetworkId({nType: NetworkIdType.Polkadot, payload: ""});
+    return NetworkId({variant: NetworkIdVariant.Polkadot, payload: ""});
 }
 
 /// @notice Creates a `Kusama` network ID.
 /// @return A `NetworkId` struct with type `Kusama` and an empty payload.
 function kusama() pure returns (NetworkId memory) {
-    return NetworkId({nType: NetworkIdType.Kusama, payload: ""});
+    return NetworkId({variant: NetworkIdVariant.Kusama, payload: ""});
 }
 
 /// @notice Creates an `Ethereum` network ID.
@@ -109,7 +108,7 @@ function ethereum(
 ) pure returns (NetworkId memory) {
     return
         NetworkId({
-            nType: NetworkIdType.Ethereum,
+            variant: NetworkIdVariant.Ethereum,
             payload: Compact.encode(params.chainId)
         });
 }

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

@@ -2,7 +2,17 @@
 pragma solidity ^0.8.28;
 
 import {Compact} from "../../../Scale/Compact.sol";
-import {NetworkId, NetworkIdType} from "./NetworkId.sol";
+import {
+    NetworkId,
+    NetworkIdVariant,
+    ByForkParams,
+    ByGenesisParams,
+    EthereumParams
+} from "./NetworkId.sol";
+import {LittleEndianU64} from "../../../LittleEndian/LittleEndianU64.sol";
+import {Bytes32} from "../../../Scale/Bytes.sol";
+import {BytesUtils} from "../../../Utils/BytesUtils.sol";
+import {UnsignedUtils} from "../../../Utils/UnsignedUtils.sol";
 
 /// @title SCALE Codec for XCM v5 `NetworkId`
 /// @notice SCALE-compliant encoder/decoder for the `NetworkId` type.
@@ -10,14 +20,13 @@ import {NetworkId, NetworkIdType} from "./NetworkId.sol";
 /// @dev XCM v5 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v5/index.html
 library NetworkIdCodec {
     error InvalidNetworkIdLength();
-    error InvalidNetworkIdType(uint8 nType);
-    error InvalidNetworkIdPayload();
+    error InvalidNetworkIdVariant(uint8 variant);
 
     /// @notice Encodes a `NetworkId` struct into SCALE format.
     function encode(
         NetworkId memory networkId
     ) internal pure returns (bytes memory) {
-        return abi.encodePacked(uint8(networkId.nType), networkId.payload);
+        return abi.encodePacked(uint8(networkId.variant), networkId.payload);
     }
 
     /// @notice Returns the number of bytes that a `NetworkId` struct would occupy when SCALE-encoded.
@@ -30,21 +39,21 @@ library NetworkIdCodec {
     ) internal pure returns (uint256) {
         if (offset >= data.length) revert InvalidNetworkIdLength();
 
-        uint8 nType = uint8(data[offset]);
+        uint8 variant = uint8(data[offset]);
         uint256 payloadLen;
 
         // Determine payload length based on type to ensure we don't over-read
-        if (nType == uint8(NetworkIdType.ByGenesis)) {
+        if (variant == uint8(NetworkIdVariant.ByGenesis)) {
             payloadLen = 32;
-        } else if (nType == uint8(NetworkIdType.ByFork)) {
+        } else if (variant == uint8(NetworkIdVariant.ByFork)) {
             payloadLen = 40; // 8 (u64) + 32 (bytes32)
-        } else if (nType == uint8(NetworkIdType.Ethereum)) {
+        } else if (variant == uint8(NetworkIdVariant.Ethereum)) {
             payloadLen = Compact.encodedSizeAt(data, offset + 1);
-        } else if (nType < 4) {
+        } else if (variant < 4) {
             payloadLen = 0; // Static variants
         } else {
             // Reserved or unknown types are invalid
-            revert InvalidNetworkIdType(nType);
+            revert InvalidNetworkIdVariant(variant);
         }
 
         if (offset + 1 + payloadLen > data.length)
@@ -70,45 +79,59 @@ library NetworkIdCodec {
         bytes memory data,
         uint256 offset
     ) internal pure returns (NetworkId memory networkId, uint256 bytesRead) {
-        if (offset >= data.length) revert InvalidNetworkIdLength();
-
-        uint8 nType = uint8(data[offset]);
-        uint256 payloadLen = encodedSizeAt(data, offset) - 1; // Subtract 1 byte for the nType
-        bytes memory payload = new bytes(payloadLen);
-        for (uint256 i = 0; i < payloadLen; i++) {
-            payload[i] = data[offset + 1 + i];
-        }
+        uint256 payloadLen = encodedSizeAt(data, offset) - 1; // Subtract 1 byte for the variant
+        uint8 variant = uint8(data[offset]);
+        bytes memory payload = BytesUtils.copy(data, offset + 1, payloadLen);
 
-        networkId = NetworkId({nType: NetworkIdType(nType), payload: payload});
+        networkId = NetworkId({
+            variant: NetworkIdVariant(variant),
+            payload: payload
+        });
 
         bytesRead = 1 + payloadLen;
     }
 
     /// @notice Decodes a `ByGenesis` network ID, returning the genesis hash.
     /// @param networkId The `NetworkId` struct to decode.
-    /// @return genesisHash The genesis hash extracted from the network ID.
+    /// @return params A `ByGenesisParams` struct containing the genesis hash extracted from the network ID.
     function asByGenesis(
         NetworkId memory networkId
-    ) internal pure returns (bytes32 genesisHash) {
-        if (networkId.nType != NetworkIdType.ByGenesis)
-            revert InvalidNetworkIdType(uint8(networkId.nType));
-        if (networkId.payload.length != 32) revert InvalidNetworkIdPayload();
-        return bytes32(networkId.payload);
+    ) internal pure returns (ByGenesisParams memory params) {
+        _assertVariant(networkId, NetworkIdVariant.ByGenesis);
+        params.genesisHash = Bytes32.decode(networkId.payload);
     }
 
-    /// @notice Decodes a `ByFork` network ID, returning the block number and hash.
+    /// @notice Decodes a `Ethereum` network ID, returning the chain ID.
     /// @param networkId The `NetworkId` struct to decode.
-    /// @return chainId The chain ID extracted from the network ID.
+    /// @return params An `EthereumParams` struct containing the chain ID extracted from the network ID.
     function asEthereum(
         NetworkId memory networkId
-    ) internal pure returns (uint64 chainId) {
-        if (networkId.nType != NetworkIdType.Ethereum)
-            revert InvalidNetworkIdType(uint8(networkId.nType));
-        if (networkId.payload.length != 8) revert InvalidNetworkIdPayload();
+    ) internal pure returns (EthereumParams memory params) {
+        _assertVariant(networkId, NetworkIdVariant.Ethereum);
         (uint256 decodedChainId, ) = Compact.decode(networkId.payload);
-        if (decodedChainId > type(uint64).max) revert InvalidNetworkIdPayload();
-        unchecked {
-            chainId = uint64(decodedChainId);
+        params.chainId = UnsignedUtils.toU64(decodedChainId);
+    }
+
+    /// @notice Decodes a `ByFork` network ID, returning the block number and block hash of the fork point.
+    /// @param networkId The `NetworkId` struct to decode.
+    /// @return params A `ByForkParams` struct containing the block number and block hash extracted from the network ID.
+    function asFork(
+        NetworkId memory networkId
+    ) internal pure returns (ByForkParams memory params) {
+        _assertVariant(networkId, NetworkIdVariant.ByFork);
+        params.blockNumber = LittleEndianU64.fromLittleEndian(
+            networkId.payload,
+            0
+        );
+        params.blockHash = Bytes32.decodeAt(networkId.payload, 8);
+    }
+
+    function _assertVariant(
+        NetworkId memory networkId,
+        NetworkIdVariant expected
+    ) private pure {
+        if (networkId.variant != expected) {
+            revert InvalidNetworkIdVariant(uint8(networkId.variant));
         }
     }
 }

package/src/Xcm/v5/OriginKind/OriginKindCodec.sol

@@ -57,7 +57,7 @@ library OriginKindCodec {
             revert InvalidOriginKindLength();
         }
         uint8 originKindValue = uint8(data[offset]);
-        if (originKindValue > uint8(OriginKind.Xcm)) {
+        if (originKindValue > uint8(type(OriginKind).max)) {
             revert InvalidOriginKind(originKindValue);
         }
         originKind = OriginKind(originKindValue);

package/src/Xcm/v5/Response/Response.sol

@@ -15,7 +15,7 @@ import {LittleEndianU32} from "../../../LittleEndian/LittleEndianU32.sol";
 import {MAX_PALLETS_INFO} from "../Constants.sol";
 
 /// @notice Discriminant for the `Response` enum.
-enum ResponseType {
+enum ResponseVariant {
     /// @custom:variant No response. Serves as a neutral default.
     Null,
     /// @custom:variant Some assets.
@@ -32,9 +32,9 @@ enum ResponseType {
 
 /// @notice Response data to a query.
 struct Response {
-    /// @custom:property The type of the response. See `ResponseType` enum for possible values.
-    ResponseType rType;
-    /// @custom:property The SCALE-encoded payload of the response. Structure depends on `rType`.
+    /// @custom:property The type of the response. See `ResponseVariant` enum for possible values.
+    ResponseVariant variant;
+    /// @custom:property The SCALE-encoded payload of the response. Structure depends on `variant`.
     bytes payload;
 }
 
@@ -44,12 +44,28 @@ struct AssetsParams {
     Assets assets;
 }
 
+/// @notice Parameters for the `ExecutionResult` response variant.
+struct ExecutionResultParams {
+    /// @custom:property Indicates if there was an error.
+    bool hasError;
+    /// @custom:property The index of the instruction that caused the error.
+    uint32 index;
+    /// @custom:property The XCM error that occurred.
+    XcmError err;
+}
+
 /// @notice Parameters for the `Version` response variant.
 struct VersionParams {
     /// @custom:property XCM version value.
     uint32 version;
 }
 
+/// @notice Parameters for the `PalletsInfo` response variant.
+struct PalletsInfoParams {
+    /// @custom:property Array of `PalletInfo` structs, containing the info of the pallets. Max length is MAX_PALLETS_INFO (64).
+    PalletInfo[] pallets;
+}
+
 /// @notice Parameters for the `DispatchResult` response variant.
 struct DispatchResultParams {
     /// @custom:property Dispatch result status.
@@ -63,7 +79,7 @@ using LittleEndianU32 for uint32;
 /// @notice Creates a `Null` response.
 /// @return A `Response` struct representing the null response.
 function null_() pure returns (Response memory) {
-    return Response({rType: ResponseType.Null, payload: ""});
+    return Response({variant: ResponseVariant.Null, payload: ""});
 }
 
 /// @notice Creates an `Assets` response.
@@ -72,39 +88,29 @@ function null_() pure returns (Response memory) {
 function assets(AssetsParams memory params) pure returns (Response memory) {
     return
         Response({
-            rType: ResponseType.Assets,
+            variant: ResponseVariant.Assets,
             payload: AssetsCodec.encode(params.assets)
         });
 }
 
-/// @notice Creates an `ExecutionResult` response with no error.
-/// @return A `Response` struct representing a successful execution result.
-function executionResultSuccess() pure returns (Response memory) {
-    // Option<(u32, Error)>: None = 0x00
-    return
-        Response({
-            rType: ResponseType.ExecutionResult,
-            payload: abi.encodePacked(uint8(0))
-        });
-}
-
-/// @notice Creates an `ExecutionResult` response with an error.
-/// @param index The index of the instruction that caused the error.
-/// @param err The XCM error that occurred.
-/// @return A `Response` struct representing a failed execution result.
-function executionResultError(
-    uint32 index,
-    XcmError memory err
+/// @notice Creates an `ExecutionResult` response.
+/// @param params Parameters for the execution result variant.
+/// @return A `Response` struct representing the execution result response.
+function executionResult(
+    ExecutionResultParams memory params
 ) pure returns (Response memory) {
+    bytes memory payload;
+    if (!params.hasError) {
+        payload = abi.encodePacked(uint8(0));
+    } else {
+        payload = abi.encodePacked(
+            uint8(1),
+            params.index.toLittleEndian(),
+            XcmErrorCodec.encode(params.err)
+        );
+    }
     return
-        Response({
-            rType: ResponseType.ExecutionResult,
-            payload: abi.encodePacked(
-                uint8(1),
-                index.toLittleEndian(),
-                XcmErrorCodec.encode(err)
-            )
-        });
+        Response({variant: ResponseVariant.ExecutionResult, payload: payload});
 }
 
 /// @notice Creates a `Version` response.
@@ -113,22 +119,25 @@ function executionResultError(
 function version(VersionParams memory params) pure returns (Response memory) {
     return
         Response({
-            rType: ResponseType.Version,
+            variant: ResponseVariant.Version,
             payload: abi.encodePacked(params.version.toLittleEndian())
         });
 }
 
 /// @notice Creates a `PalletsInfo` response.
-/// @param pallets The pallet info array. Max length is MAX_PALLETS_INFO (64).
+/// @param params Parameters for the pallets info variant.
 /// @return A `Response` struct representing the pallets info response.
 function palletsInfo(
-    PalletInfo[] memory pallets
+    PalletsInfoParams memory params
 ) pure returns (Response memory) {
-    bytes memory encoded = Compact.encode(pallets.length);
-    for (uint256 i = 0; i < pallets.length; ++i) {
-        encoded = bytes.concat(encoded, PalletInfoCodec.encode(pallets[i]));
+    bytes memory encoded = Compact.encode(params.pallets.length);
+    for (uint256 i = 0; i < params.pallets.length; ++i) {
+        encoded = bytes.concat(
+            encoded,
+            PalletInfoCodec.encode(params.pallets[i])
+        );
     }
-    return Response({rType: ResponseType.PalletsInfo, payload: encoded});
+    return Response({variant: ResponseVariant.PalletsInfo, payload: encoded});
 }
 
 /// @notice Creates a `DispatchResult` response.
@@ -139,7 +148,7 @@ function dispatchResult(
 ) pure returns (Response memory) {
     return
         Response({
-            rType: ResponseType.DispatchResult,
+            variant: ResponseVariant.DispatchResult,
             payload: MaybeErrorCodeCodec.encode(params.result)
         });
 }

package/src/Xcm/v5/Response/ResponseCodec.sol

@@ -11,7 +11,17 @@ import {MaybeErrorCode} from "../../v3/MaybeErrorCode/MaybeErrorCode.sol";
 import {MaybeErrorCodeCodec} from "../../v3/MaybeErrorCode/MaybeErrorCodeCodec.sol";
 import {Compact} from "../../../Scale/Compact.sol";
 import {LittleEndianU32} from "../../../LittleEndian/LittleEndianU32.sol";
-import {Response, ResponseType} from "./Response.sol";
+import {
+    Response,
+    ResponseVariant,
+    AssetsParams,
+    VersionParams,
+    DispatchResultParams,
+    ExecutionResultParams,
+    PalletsInfoParams
+} from "./Response.sol";
+
+import {BytesUtils} from "../../../Utils/BytesUtils.sol";
 
 /// @title SCALE Codec for XCM v5 `Response`
 /// @notice SCALE-compliant encoder/decoder for the `Response` type.
@@ -19,13 +29,13 @@ import {Response, ResponseType} from "./Response.sol";
 /// @dev XCM v5 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v5/index.html
 library ResponseCodec {
     error InvalidResponseLength();
-    error InvalidResponseType(uint8 rType);
+    error InvalidResponseVariant(uint8 variant);
 
     /// @notice Encodes a `Response` struct into SCALE bytes.
     /// @param r The `Response` struct to encode.
     /// @return SCALE-encoded bytes representing the `Response`.
     function encode(Response memory r) internal pure returns (bytes memory) {
-        return abi.encodePacked(uint8(r.rType), r.payload);
+        return abi.encodePacked(uint8(r.variant), r.payload);
     }
 
     /// @notice Returns the number of bytes that a `Response` would occupy when SCALE-encoded.
@@ -37,22 +47,22 @@ library ResponseCodec {
         uint256 offset
     ) internal pure returns (uint256) {
         if (data.length < offset + 1) revert InvalidResponseLength();
-        uint8 rType = uint8(data[offset]);
+        uint8 variant = uint8(data[offset]);
         uint256 pos = offset + 1;
 
-        if (rType == uint8(ResponseType.Null)) {
+        if (variant == uint8(ResponseVariant.Null)) {
             return 1;
-        } else if (rType == uint8(ResponseType.Assets)) {
+        } else if (variant == uint8(ResponseVariant.Assets)) {
             return 1 + AssetsCodec.encodedSizeAt(data, pos);
-        } else if (rType == uint8(ResponseType.ExecutionResult)) {
+        } else if (variant == uint8(ResponseVariant.ExecutionResult)) {
             if (data.length < pos + 1) revert InvalidResponseLength();
             uint8 isSome = uint8(data[pos]);
             if (isSome == 0) return 2; // 1 type + 1 None byte
             return 2 + 4 + XcmErrorCodec.encodedSizeAt(data, pos + 1 + 4);
-        } else if (rType == uint8(ResponseType.Version)) {
+        } else if (variant == uint8(ResponseVariant.Version)) {
             if (data.length < pos + 4) revert InvalidResponseLength();
             return 1 + 4; // 1 type + 4 bytes for version
-        } else if (rType == uint8(ResponseType.PalletsInfo)) {
+        } else if (variant == uint8(ResponseVariant.PalletsInfo)) {
             (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, pos);
             uint256 size = prefixSize;
             uint256 innerPos = pos + prefixSize;
@@ -65,10 +75,10 @@ library ResponseCodec {
                 innerPos += palletSize;
             }
             return 1 + size;
-        } else if (rType == uint8(ResponseType.DispatchResult)) {
+        } else if (variant == uint8(ResponseVariant.DispatchResult)) {
             return 1 + MaybeErrorCodeCodec.encodedSizeAt(data, pos);
         } else {
-            revert InvalidResponseType(rType);
+            revert InvalidResponseVariant(variant);
         }
     }
 
@@ -91,84 +101,84 @@ library ResponseCodec {
         bytes memory data,
         uint256 offset
     ) internal pure returns (Response memory r, uint256 bytesRead) {
-        if (data.length < offset + 1) revert InvalidResponseLength();
-        uint8 rType = uint8(data[offset]);
         uint256 size = encodedSizeAt(data, offset);
+        uint8 variant = uint8(data[offset]);
         uint256 payloadLength = size - 1;
-        bytes memory payload = new bytes(payloadLength);
-        for (uint256 i = 0; i < payloadLength; ++i) {
-            payload[i] = data[offset + 1 + i];
-        }
-        r = Response({rType: ResponseType(rType), payload: payload});
+        bytes memory payload = BytesUtils.copy(data, offset + 1, payloadLength);
+        r = Response({variant: ResponseVariant(variant), payload: payload});
         bytesRead = size;
     }
 
     /// @notice Decodes the `Assets` from an `Assets` response.
     /// @param r The `Response` struct. Must be of type `Assets`.
-    /// @return The decoded `Assets`.
-    function asAssets(Response memory r) internal pure returns (Assets memory) {
-        if (r.rType != ResponseType.Assets)
-            revert InvalidResponseType(uint8(r.rType));
-        (Assets memory a, ) = AssetsCodec.decode(r.payload);
-        return a;
+    /// @return params An `AssetsParams` struct containing the decoded assets.
+    function asAssets(
+        Response memory r
+    ) internal pure returns (AssetsParams memory params) {
+        _assertVariant(r, ResponseVariant.Assets);
+        (params.assets, ) = AssetsCodec.decode(r.payload);
     }
 
     /// @notice Decodes the execution result from an `ExecutionResult` response.
     /// @param r The `Response` struct. Must be of type `ExecutionResult`.
-    /// @return hasError Whether the execution result contains an error.
-    /// @return index The instruction index that caused the error. Only meaningful if `hasError` is true.
-    /// @return err The XCM error. Only meaningful if `hasError` is true.
+    /// @return params An `ExecutionResultParams` struct containing the execution result details.
     function asExecutionResult(
         Response memory r
-    ) internal pure returns (bool hasError, uint32 index, XcmError memory err) {
-        if (r.rType != ResponseType.ExecutionResult)
-            revert InvalidResponseType(uint8(r.rType));
-        if (r.payload.length < 1) revert InvalidResponseLength();
-        hasError = r.payload[0] != 0;
-        if (hasError) {
-            if (r.payload.length < 4) revert InvalidResponseLength();
-            index = LittleEndianU32.fromLittleEndian(r.payload, 1);
-            (err, ) = XcmErrorCodec.decodeAt(r.payload, 1 + 4);
+    ) internal pure returns (ExecutionResultParams memory params) {
+        _assertVariant(r, ResponseVariant.ExecutionResult);
+        params.hasError = r.payload[0] != 0;
+        if (params.hasError) {
+            params.index = LittleEndianU32.fromLittleEndian(r.payload, 1);
+            (params.err, ) = XcmErrorCodec.decodeAt(r.payload, 1 + 4);
         }
     }
 
     /// @notice Decodes the version from a `Version` response.
     /// @param r The `Response` struct. Must be of type `Version`.
-    /// @return The decoded version.
-    function asVersion(Response memory r) internal pure returns (uint32) {
-        if (r.rType != ResponseType.Version)
-            revert InvalidResponseType(uint8(r.rType));
-        if (r.payload.length != 4) revert InvalidResponseLength();
-        return LittleEndianU32.fromLittleEndian(r.payload, 0);
+    /// @return params A `VersionParams` struct containing the decoded version number.
+    function asVersion(
+        Response memory r
+    ) internal pure returns (VersionParams memory params) {
+        _assertVariant(r, ResponseVariant.Version);
+        params.version = LittleEndianU32.fromLittleEndian(r.payload, 0);
     }
 
     /// @notice Decodes the pallets info from a `PalletsInfo` response.
     /// @param r The `Response` struct. Must be of type `PalletsInfo`.
-    /// @return pallets The decoded array of `PalletInfo`.
+    /// @return params A `PalletsInfoParams` struct containing the decoded array of `PalletInfo`.
     function asPalletsInfo(
         Response memory r
-    ) internal pure returns (PalletInfo[] memory pallets) {
-        if (r.rType != ResponseType.PalletsInfo)
-            revert InvalidResponseType(uint8(r.rType));
+    ) internal pure returns (PalletsInfoParams memory params) {
+        _assertVariant(r, ResponseVariant.PalletsInfo);
         (uint256 count, uint256 prefixSize) = Compact.decodeAt(r.payload, 0);
-        pallets = new PalletInfo[](count);
+        params.pallets = new PalletInfo[](count);
         uint256 pos = prefixSize;
         for (uint256 i = 0; i < count; ++i) {
             uint256 read;
-            (pallets[i], read) = PalletInfoCodec.decodeAt(r.payload, pos);
+            (params.pallets[i], read) = PalletInfoCodec.decodeAt(
+                r.payload,
+                pos
+            );
             pos += read;
         }
     }
 
     /// @notice Decodes the dispatch result from a `DispatchResult` response.
     /// @param r The `Response` struct. Must be of type `DispatchResult`.
-    /// @return The decoded `MaybeErrorCode`.
+    /// @return params A `DispatchResultParams` struct containing the decoded dispatch result.
     function asDispatchResult(
         Response memory r
-    ) internal pure returns (MaybeErrorCode memory) {
-        if (r.rType != ResponseType.DispatchResult)
-            revert InvalidResponseType(uint8(r.rType));
-        (MaybeErrorCode memory me, ) = MaybeErrorCodeCodec.decode(r.payload);
-        return me;
+    ) internal pure returns (DispatchResultParams memory params) {
+        _assertVariant(r, ResponseVariant.DispatchResult);
+        (params.result, ) = MaybeErrorCodeCodec.decode(r.payload);
+    }
+
+    function _assertVariant(
+        Response memory r,
+        ResponseVariant expected
+    ) internal pure {
+        if (r.variant != expected) {
+            revert InvalidResponseVariant(uint8(r.variant));
+        }
     }
 }

package/src/Xcm/v5/Weight/WeightCodec.sol

@@ -3,6 +3,7 @@ pragma solidity ^0.8.28;
 
 import {Compact} from "../../../Scale/Compact.sol";
 import {Weight} from "./Weight.sol";
+import {UnsignedUtils} from "../../../Utils/UnsignedUtils.sol";
 
 /// @title SCALE Codec for XCM v5 `Weight`
 /// @notice SCALE-compliant encoder/decoder for the `Weight` type.
@@ -79,8 +80,8 @@ library WeightCodec {
         offset += proofSizeBytes;
 
         weight = Weight({
-            refTime: uint64(refTime),
-            proofSize: uint64(proofSize)
+            refTime: UnsignedUtils.toU64(refTime),
+            proofSize: UnsignedUtils.toU64(proofSize)
         });
         bytesRead = refTimeBytes + proofSizeBytes;
     }

package/src/Xcm/v5/WeightLimit/WeightLimit.sol

@@ -5,7 +5,7 @@ import {Weight} from "../Weight/Weight.sol";
 import {WeightCodec} from "../Weight/WeightCodec.sol";
 
 /// @notice Discriminant for the `WeightLimit` enum.
-enum WeightLimitType {
+enum WeightLimitVariant {
     /// @custom:variant No limit on weight.
     Unlimited,
     /// @custom:variant A specific weight limit.
@@ -14,9 +14,9 @@ enum WeightLimitType {
 
 /// @notice An optional weight limit.
 struct WeightLimit {
-    /// @custom:property The type of the weight limit. See `WeightLimitType` enum for possible values.
-    WeightLimitType wlType;
-    /// @custom:property The SCALE-encoded `Weight`. Only meaningful when `wlType` is `Limited`.
+    /// @custom:property The type of the weight limit. See `WeightLimitVariant` enum for possible values.
+    WeightLimitVariant variant;
+    /// @custom:property The SCALE-encoded `Weight`. Only meaningful when `variant` is `Limited`.
     bytes payload;
 }
 
@@ -31,7 +31,7 @@ struct LimitedParams {
 /// @notice Creates an `Unlimited` weight limit.
 /// @return A `WeightLimit` struct representing no limit.
 function unlimited() pure returns (WeightLimit memory) {
-    return WeightLimit({wlType: WeightLimitType.Unlimited, payload: ""});
+    return WeightLimit({variant: WeightLimitVariant.Unlimited, payload: ""});
 }
 
 /// @notice Creates a `Limited` weight limit with the given `Weight`.
@@ -42,7 +42,7 @@ function limited(
 ) pure returns (WeightLimit memory) {
     return
         WeightLimit({
-            wlType: WeightLimitType.Limited,
+            variant: WeightLimitVariant.Limited,
             payload: WeightCodec.encode(params.weight)
         });
 }