solidity-scale-codec 0.1.3 → 0.2.0

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

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Compact} from "../../../Scale/Compact.sol";
+import {NetworkId, NetworkIdType} from "./NetworkId.sol";
+
+/// @title SCALE Codec for XCM v5 `NetworkId`
+/// @notice SCALE-compliant encoder/decoder for the `NetworkId` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+/// @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();
+
+    /// @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);
+    }
+
+    /// @notice Returns the number of bytes that a `NetworkId` struct would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `NetworkId`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `NetworkId`.
+    /// @return The number of bytes that the `NetworkId` struct would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (offset >= data.length) revert InvalidNetworkIdLength();
+
+        uint8 nType = uint8(data[offset]);
+        uint256 payloadLen;
+
+        // Determine payload length based on type to ensure we don't over-read
+        if (nType == uint8(NetworkIdType.ByGenesis)) {
+            payloadLen = 32;
+        } else if (nType == uint8(NetworkIdType.ByFork)) {
+            payloadLen = 40; // 8 (u64) + 32 (bytes32)
+        } else if (nType == uint8(NetworkIdType.Ethereum)) {
+            payloadLen = Compact.encodedSizeAt(data, offset + 1);
+        } else if (nType < 4) {
+            payloadLen = 0; // Static variants
+        } else {
+            // Reserved or unknown types are invalid
+            revert InvalidNetworkIdType(nType);
+        }
+
+        if (offset + 1 + payloadLen > data.length)
+            revert InvalidNetworkIdLength();
+
+        return 1 + payloadLen;
+    }
+
+    /// @notice Decodes a byte array into a `NetworkId` struct.
+    /// @param data The byte array to decode.
+    /// @return networkId The decoded `NetworkId` struct.
+    function decode(
+        bytes memory data
+    ) internal pure returns (NetworkId memory networkId, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes a byte array into a `NetworkId` struct.
+    /// @param data The byte array to decode.
+    /// @param offset The byte offset to start decoding from.
+    /// @return networkId The decoded `NetworkId` struct.
+    function decodeAt(
+        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];
+        }
+
+        networkId = NetworkId({nType: NetworkIdType(nType), 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.
+    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);
+    }
+
+    /// @notice Decodes a `ByFork` network ID, returning the block number and hash.
+    /// @param networkId The `NetworkId` struct to decode.
+    /// @return chainId 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();
+        (uint256 decodedChainId, ) = Compact.decode(networkId.payload);
+        if (decodedChainId > type(uint64).max) revert InvalidNetworkIdPayload();
+        unchecked {
+            chainId = uint64(decodedChainId);
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+/// @notice Basically just the XCM (more general) version of ParachainDispatchOrigin.
+enum OriginKind {
+    /// @custom:variant Origin should just be the native dispatch origin representation for the sender in the local runtime framework. For Cumulus/Frame chains this is the Parachain or Relay origin if coming from a chain, though there may be others if the MultiLocation XCM origin has a primary/native dispatch origin form.
+    Native,
+    /// @custom:variant Origin should just be the standard account-based origin with the sovereign account of the sender. For Cumulus/Frame chains, this is the Signed origin.
+    SovereignAccount,
+    /// @custom:variant Origin should be the super-user. For Cumulus/Frame chains, this is the Root origin. This will not usually be an available option.
+    Superuser,
+    /// @custom:variant Origin should be interpreted as an XCM native origin and the MultiLocation should be encoded directly in the dispatch origin unchanged. For Cumulus/Frame chains, this will be the `pallet_xcm::Origin::Xcm` type.
+    Xcm
+}

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

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {OriginKind} from "./OriginKind.sol";
+
+/// @title SCALE Codec for XCM v5 `OriginKind`
+/// @notice SCALE-compliant encoder/decoder for the `OriginKind` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+/// @dev XCM v5 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v5/index.html
+library OriginKindCodec {
+    error InvalidOriginKindLength();
+    error InvalidOriginKind(uint8 originKind);
+
+    /// @notice Encodes an `OriginKind` enum value into a bytes array using SCALE encoding.
+    /// @param originKind The `OriginKind` value to encode.
+    /// @return A bytes array containing the SCALE-encoded `OriginKind`.
+    function encode(
+        OriginKind originKind
+    ) internal pure returns (bytes memory) {
+        return abi.encodePacked(uint8(originKind));
+    }
+
+    /// @notice Returns the number of bytes that an `OriginKind` enum value would occupy when SCALE-encoded.
+    /// @param data The bytes array containing the encoded `OriginKind`.
+    /// @param offset The byte offset in the data array to start calculating from.
+    /// @return The number of bytes that the `OriginKind` enum value would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (offset >= data.length) {
+            revert InvalidOriginKindLength();
+        }
+        return 1;
+    }
+
+    /// @notice Decodes a bytes array into an `OriginKind` enum value using SCALE decoding.
+    /// @param data The bytes array containing the SCALE-encoded `OriginKind`.
+    /// @return originKind The decoded `OriginKind` value.
+    /// @return bytesRead The number of bytes read from the data array during decoding.
+    function decode(
+        bytes memory data
+    ) internal pure returns (OriginKind originKind, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes a bytes array into an `OriginKind` enum value starting at a specific offset.
+    /// @param data The bytes array containing the SCALE-encoded `OriginKind`.
+    /// @param offset The byte offset in the data array to start decoding from.
+    /// @return originKind The decoded `OriginKind` value.
+    /// @return bytesRead The number of bytes read from the data array during decoding.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (OriginKind originKind, uint256 bytesRead) {
+        if (offset >= data.length) {
+            revert InvalidOriginKindLength();
+        }
+        uint8 originKindValue = uint8(data[offset]);
+        if (originKindValue > uint8(OriginKind.Xcm)) {
+            revert InvalidOriginKind(originKindValue);
+        }
+        originKind = OriginKind(originKindValue);
+        bytesRead = 1;
+    }
+}

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

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+/// @notice Information about a pallet on a Substrate-based chain.
+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;
+    /// @custom:property The module name of the pallet. Max length is `MAX_PALLET_NAME_LEN`.
+    uint8[] 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.
+    uint32 minor;
+    /// @custom:property The patch version of the crate which implements the pallet.
+    uint32 patch;
+}

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

@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Compact} from "../../../Scale/Compact.sol";
+import {U8Arr} from "../../../Scale/Array.sol";
+import {MAX_PALLET_NAME_LEN} from "../Constants.sol";
+import {PalletInfo} from "./PalletInfo.sol";
+
+/// @title SCALE Codec for XCM v5 `PalletInfo`
+/// @notice SCALE-compliant encoder/decoder for the `PalletInfo` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+/// @dev XCM v5 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v5/index.html
+library PalletInfoCodec {
+    error InvalidPalletInfoLength();
+    error PalletNameTooLong(uint256 length);
+
+    /// @notice Encodes a `PalletInfo` struct into SCALE bytes.
+    /// @param info The `PalletInfo` struct to encode.
+    /// @return SCALE-encoded bytes representing the `PalletInfo`.
+    function encode(
+        PalletInfo memory info
+    ) internal pure returns (bytes memory) {
+        if (info.name.length > MAX_PALLET_NAME_LEN)
+            revert PalletNameTooLong(info.name.length);
+        if (info.moduleName.length > MAX_PALLET_NAME_LEN)
+            revert PalletNameTooLong(info.moduleName.length);
+        return
+            abi.encodePacked(
+                Compact.encode(info.index),
+                U8Arr.encode(info.name),
+                U8Arr.encode(info.moduleName),
+                Compact.encode(info.major),
+                Compact.encode(info.minor),
+                Compact.encode(info.patch)
+            );
+    }
+
+    /// @notice Returns the number of bytes that a `PalletInfo` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `PalletInfo`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size.
+    /// @return The number of bytes occupied by the encoded `PalletInfo`.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        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 += Compact.encodedSizeAt(data, pos); // major
+        pos += Compact.encodedSizeAt(data, pos); // minor
+        pos += Compact.encodedSizeAt(data, pos); // patch
+        return pos - offset;
+    }
+
+    /// @notice Decodes a `PalletInfo` from SCALE bytes starting at the beginning.
+    /// @param data The byte sequence containing the encoded `PalletInfo`.
+    /// @return info The decoded `PalletInfo` struct.
+    /// @return bytesRead The number of bytes read.
+    function decode(
+        bytes memory data
+    ) internal pure returns (PalletInfo memory info, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes a `PalletInfo` from SCALE bytes starting at a given offset.
+    /// @param data The byte sequence containing the encoded `PalletInfo`.
+    /// @param offset The starting index in `data` from which to decode.
+    /// @return info The decoded `PalletInfo` struct.
+    /// @return bytesRead The number of bytes read.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (PalletInfo memory info, uint256 bytesRead) {
+        uint256 pos = offset;
+        uint256 index;
+        uint256 read;
+
+        (index, read) = Compact.decodeAt(data, pos);
+        pos += read;
+
+        uint8[] memory name;
+        (name, read) = U8Arr.decodeAt(data, pos);
+        pos += read;
+
+        uint8[] memory moduleName;
+        (moduleName, read) = U8Arr.decodeAt(data, pos);
+        pos += read;
+
+        uint256 major;
+        (major, read) = Compact.decodeAt(data, pos);
+        pos += read;
+
+        uint256 minor;
+        (minor, read) = Compact.decodeAt(data, pos);
+        pos += read;
+
+        uint256 patch;
+        (patch, read) = Compact.decodeAt(data, pos);
+        pos += read;
+
+        if (name.length > MAX_PALLET_NAME_LEN)
+            revert PalletNameTooLong(name.length);
+
+        if (moduleName.length > MAX_PALLET_NAME_LEN)
+            revert PalletNameTooLong(moduleName.length);
+
+        info = PalletInfo({
+            index: uint32(index),
+            name: name,
+            moduleName: moduleName,
+            major: uint32(major),
+            minor: uint32(minor),
+            patch: uint32(patch)
+        });
+        bytesRead = pos - offset;
+    }
+}

package/src/Xcm/v5/QueryResponseInfo/QueryResponseInfo.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Location} from "../Location/Location.sol";
+import {Weight} from "../Weight/Weight.sol";
+import {QueryId} from "../Types/QueryId.sol";
+
+/// @notice Information regarding the composition of a query response.
+struct QueryResponseInfo {
+    /// @custom:property The destination to which the query response message should be sent.
+    Location destination;
+    /// @custom:property The `query_id` field of the `QueryResponse` message.
+    QueryId queryId;
+    /// @custom:property The `max_weight` field of the `QueryResponse` message.
+    Weight maxWeight;
+}

package/src/Xcm/v5/QueryResponseInfo/QueryResponseInfoCodec.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Location} from "../Location/Location.sol";
+import {LocationCodec} from "../Location/LocationCodec.sol";
+import {Weight} from "../Weight/Weight.sol";
+import {WeightCodec} from "../Weight/WeightCodec.sol";
+import {QueryId} from "../Types/QueryId.sol";
+import {Compact} from "../../../Scale/Compact.sol";
+import {QueryResponseInfo} from "./QueryResponseInfo.sol";
+
+/// @title SCALE Codec for XCM v5 `QueryResponseInfo`
+/// @notice SCALE-compliant encoder/decoder for the `QueryResponseInfo` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+/// @dev XCM v5 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v5/index.html
+library QueryResponseInfoCodec {
+    error InvalidQueryResponseInfoLength();
+
+    /// @notice Encodes a `QueryResponseInfo` struct into SCALE bytes.
+    /// @param info The `QueryResponseInfo` struct to encode.
+    /// @return SCALE-encoded bytes representing the `QueryResponseInfo`.
+    function encode(
+        QueryResponseInfo memory info
+    ) internal pure returns (bytes memory) {
+        return
+            abi.encodePacked(
+                LocationCodec.encode(info.destination),
+                Compact.encode(QueryId.unwrap(info.queryId)),
+                WeightCodec.encode(info.maxWeight)
+            );
+    }
+
+    /// @notice Returns the number of bytes that a `QueryResponseInfo` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `QueryResponseInfo`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size.
+    /// @return The number of bytes occupied by the encoded `QueryResponseInfo`.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (data.length < offset + 1) revert InvalidQueryResponseInfoLength();
+        uint256 pos = offset;
+        pos += LocationCodec.encodedSizeAt(data, pos);
+        pos += Compact.encodedSizeAt(data, pos);
+        pos += WeightCodec.encodedSizeAt(data, pos);
+        return pos - offset;
+    }
+
+    /// @notice Decodes a `QueryResponseInfo` from SCALE bytes starting at the beginning.
+    /// @param data The byte sequence containing the encoded `QueryResponseInfo`.
+    /// @return info The decoded `QueryResponseInfo` struct.
+    /// @return bytesRead The number of bytes read.
+    function decode(
+        bytes memory data
+    ) internal pure returns (QueryResponseInfo memory info, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes a `QueryResponseInfo` from SCALE bytes starting at a given offset.
+    /// @param data The byte sequence containing the encoded `QueryResponseInfo`.
+    /// @param offset The starting index in `data` from which to decode.
+    /// @return info The decoded `QueryResponseInfo` struct.
+    /// @return bytesRead The number of bytes read.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (QueryResponseInfo memory info, uint256 bytesRead) {
+        if (data.length < offset + 1) revert InvalidQueryResponseInfoLength();
+        uint256 pos = offset;
+        uint256 read;
+
+        Location memory destination;
+        (destination, read) = LocationCodec.decodeAt(data, pos);
+        pos += read;
+
+        uint256 queryId;
+        (queryId, read) = Compact.decodeAt(data, pos);
+        pos += read;
+
+        Weight memory maxWeight;
+        (maxWeight, read) = WeightCodec.decodeAt(data, pos);
+        pos += read;
+
+        info = QueryResponseInfo({
+            destination: destination,
+            queryId: QueryId.wrap(uint64(queryId)),
+            maxWeight: maxWeight
+        });
+        bytesRead = pos - offset;
+    }
+}

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

@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Assets} from "../Assets/Assets.sol";
+import {AssetsCodec} from "../Assets/AssetsCodec.sol";
+import {XcmError} from "../XcmError/XcmError.sol";
+import {XcmErrorCodec} from "../XcmError/XcmErrorCodec.sol";
+import {PalletInfo} from "../PalletInfo/PalletInfo.sol";
+import {PalletInfoCodec} from "../PalletInfo/PalletInfoCodec.sol";
+import {MaybeErrorCode} from "../../v3/MaybeErrorCode/MaybeErrorCode.sol";
+import {MaybeErrorCodeCodec} from "../../v3/MaybeErrorCode/MaybeErrorCodeCodec.sol";
+import {Version} from "../../Types/Version.sol";
+import {Compact} from "../../../Scale/Compact.sol";
+import {LittleEndianU32} from "../../../LittleEndian/LittleEndianU32.sol";
+import {MAX_PALLETS_INFO} from "../Constants.sol";
+
+/// @notice Discriminant for the `Response` enum.
+enum ResponseType {
+    /// @custom:variant No response. Serves as a neutral default.
+    Null,
+    /// @custom:variant Some assets.
+    Assets,
+    /// @custom:variant The outcome of an XCM instruction.
+    ExecutionResult,
+    /// @custom:variant An XCM version.
+    Version,
+    /// @custom:variant The index, instance name, pallet name and version of some pallets.
+    PalletsInfo,
+    /// @custom:variant The status of a dispatch attempt using `Transact`.
+    DispatchResult
+}
+
+/// @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`.
+    bytes payload;
+}
+
+/// @notice Parameters for the `Assets` response variant.
+struct AssetsParams {
+    /// @custom:property Assets payload.
+    Assets assets;
+}
+
+/// @notice Parameters for the `Version` response variant.
+struct VersionParams {
+    /// @custom:property XCM version value.
+    uint32 version;
+}
+
+/// @notice Parameters for the `DispatchResult` response variant.
+struct DispatchResultParams {
+    /// @custom:property Dispatch result status.
+    MaybeErrorCode result;
+}
+
+using LittleEndianU32 for uint32;
+
+// ============ Factory Functions ============
+
+/// @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: ""});
+}
+
+/// @notice Creates an `Assets` response.
+/// @param params Parameters for the assets variant.
+/// @return A `Response` struct representing the assets response.
+function assets(AssetsParams memory params) pure returns (Response memory) {
+    return
+        Response({
+            rType: ResponseType.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
+) pure returns (Response memory) {
+    return
+        Response({
+            rType: ResponseType.ExecutionResult,
+            payload: abi.encodePacked(
+                uint8(1),
+                index.toLittleEndian(),
+                XcmErrorCodec.encode(err)
+            )
+        });
+}
+
+/// @notice Creates a `Version` response.
+/// @param params Parameters for the version variant.
+/// @return A `Response` struct representing the version response.
+function version(VersionParams memory params) pure returns (Response memory) {
+    return
+        Response({
+            rType: ResponseType.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).
+/// @return A `Response` struct representing the pallets info response.
+function palletsInfo(
+    PalletInfo[] memory pallets
+) 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]));
+    }
+    return Response({rType: ResponseType.PalletsInfo, payload: encoded});
+}
+
+/// @notice Creates a `DispatchResult` response.
+/// @param params Parameters for the dispatch-result variant.
+/// @return A `Response` struct representing the dispatch result response.
+function dispatchResult(
+    DispatchResultParams memory params
+) pure returns (Response memory) {
+    return
+        Response({
+            rType: ResponseType.DispatchResult,
+            payload: MaybeErrorCodeCodec.encode(params.result)
+        });
+}