solidity-scale-codec 0.1.2 → 0.2.0

package/src/Xcm/v5/WildAsset/WildAssetCodec.sol

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Compact} from "../../../Scale/Compact.sol";
+import {AssetIdCodec} from "../AssetId/AssetIdCodec.sol";
+import {WildFungibilityCodec} from "../WildFungibility/WildFungibilityCodec.sol";
+import {AssetId} from "../AssetId/AssetId.sol";
+import {WildFungibility} from "../WildFungibility/WildFungibility.sol";
+import {
+    WildAsset,
+    WildAssetType,
+    AllOfParams,
+    AllOfCountedParams
+} from "./WildAsset.sol";
+
+/// @title SCALE Codec for XCM v5 `WildAsset`
+/// @notice SCALE-compliant encoder/decoder for the `WildAsset` 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 WildAssetCodec {
+    error InvalidWildAssetLength();
+    error InvalidWildAssetType(uint8 waType);
+    error InvalidWildAssetPayload();
+
+    /// @notice Encodes a `WildAsset` struct into bytes.
+    /// @param wildAsset The `WildAsset` struct to encode.
+    /// @return SCALE-encoded byte sequence representing the `WildAsset`.
+    function encode(
+        WildAsset memory wildAsset
+    ) internal pure returns (bytes memory) {
+        return abi.encodePacked(uint8(wildAsset.waType), wildAsset.payload);
+    }
+
+    /// @notice Returns the number of bytes that a `WildAsset` struct would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `WildAsset`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `WildAsset`.
+    /// @return The number of bytes that the `WildAsset` struct would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (offset >= data.length) {
+            revert InvalidWildAssetLength();
+        }
+        uint8 waType = uint8(data[offset]);
+        if (waType > uint8(WildAssetType.AllOfCounted)) {
+            revert InvalidWildAssetType(waType);
+        }
+        uint256 payloadLength;
+        if (waType == uint8(WildAssetType.All)) {
+            payloadLength = 0;
+        } else if (waType == uint8(WildAssetType.AllOf)) {
+            uint256 idSize = AssetIdCodec.encodedSizeAt(data, offset + 1);
+            payloadLength =
+                idSize +
+                WildFungibilityCodec.encodedSizeAt(data, offset + 1 + idSize);
+        } else if (waType == uint8(WildAssetType.AllCounted)) {
+            payloadLength = Compact.encodedSizeAt(data, offset + 1);
+        } else if (waType == uint8(WildAssetType.AllOfCounted)) {
+            uint256 idSize = AssetIdCodec.encodedSizeAt(data, offset + 1);
+            uint256 funSize = WildFungibilityCodec.encodedSizeAt(
+                data,
+                offset + 1 + idSize
+            );
+            payloadLength =
+                idSize +
+                funSize +
+                Compact.encodedSizeAt(data, offset + 1 + idSize + funSize);
+        } else {
+            revert InvalidWildAssetType(waType);
+        }
+        return 1 + payloadLength; // 1 byte for the waType
+    }
+
+    /// @notice Decodes a `WildAsset` instance from bytes starting at the beginning of the data.
+    /// @param data The byte sequence containing the encoded `WildAsset`.
+    /// @return wildAsset The decoded `WildAsset` struct.
+    /// @return bytesRead The total number of bytes read from `data` to decode the `WildAsset`.
+    function decode(
+        bytes memory data
+    ) internal pure returns (WildAsset memory wildAsset, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes a `WildAsset` instance from bytes starting at a given offset.
+    /// @param data The byte sequence containing the encoded `WildAsset`.
+    /// @param offset The starting index in `data` from which to decode the `WildAsset`.
+    /// @return wildAsset The decoded `WildAsset` struct.
+    /// @return bytesRead The total number of bytes read from `data` to decode the `WildAsset`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (WildAsset memory wildAsset, uint256 bytesRead) {
+        if (offset >= data.length) {
+            revert InvalidWildAssetLength();
+        }
+        uint8 waType = uint8(data[offset]);
+        if (waType > uint8(WildAssetType.AllOfCounted)) {
+            revert InvalidWildAssetType(waType);
+        }
+        wildAsset.waType = WildAssetType(waType);
+        uint256 payloadLength = encodedSizeAt(data, offset) - 1; // subtract 1 byte for the waType
+        wildAsset.payload = new bytes(payloadLength);
+        for (uint256 i = 0; i < payloadLength; i++) {
+            wildAsset.payload[i] = data[offset + 1 + i];
+        }
+        bytesRead = 1 + payloadLength;
+    }
+
+    /// @notice Decodes the parameters of a `WildAsset` with the `AllOf` variant from its payload.
+    /// @param wildAsset The `WildAsset` struct. Must have the `AllOf` variant.
+    /// @return params An `AllOfParams` struct containing the decoded parameters from the payload.
+    function asAllOf(
+        WildAsset memory wildAsset
+    ) internal pure returns (AllOfParams memory params) {
+        if (wildAsset.waType != WildAssetType.AllOf) {
+            revert InvalidWildAssetType(uint8(wildAsset.waType));
+        }
+        uint256 bytesRead;
+        (params.id, bytesRead) = AssetIdCodec.decode(wildAsset.payload);
+        (params.fun, ) = WildFungibilityCodec.decodeAt(
+            wildAsset.payload,
+            bytesRead
+        );
+    }
+
+    /// @notice Decodes the parameters of a `WildAsset` with the `AllCounted` variant from its payload.
+    /// @param wildAsset The `WildAsset` struct. Must have the `AllCounted` variant.
+    /// @return count The `count` parameter decoded from the payload, representing the limit of assets to match against.
+    function asAllCounted(
+        WildAsset memory wildAsset
+    ) internal pure returns (uint32 count) {
+        if (wildAsset.waType != WildAssetType.AllCounted) {
+            revert InvalidWildAssetType(uint8(wildAsset.waType));
+        }
+        uint256 decodedCount;
+        (decodedCount, ) = Compact.decode(wildAsset.payload);
+        count = uint32(decodedCount);
+    }
+
+    /// @notice Decodes the parameters of a `WildAsset` with the `AllOfCounted` variant from its payload.
+    /// @param wildAsset The `WildAsset` struct. Must have the `AllOfCounted` variant.
+    /// @return params An `AllOfCountedParams` struct containing the decoded parameters from the payload, including the asset class, fungibility, and count limit.
+    function asAllOfCounted(
+        WildAsset memory wildAsset
+    ) internal pure returns (AllOfCountedParams memory params) {
+        if (wildAsset.waType != WildAssetType.AllOfCounted) {
+            revert InvalidWildAssetType(uint8(wildAsset.waType));
+        }
+        uint256 offset = 0;
+        uint256 bytesRead;
+        (params.id, bytesRead) = AssetIdCodec.decodeAt(
+            wildAsset.payload,
+            offset
+        );
+        offset += bytesRead;
+        (params.fun, bytesRead) = WildFungibilityCodec.decodeAt(
+            wildAsset.payload,
+            offset
+        );
+        offset += bytesRead;
+        uint256 decodedCount;
+        (decodedCount, ) = Compact.decodeAt(wildAsset.payload, offset);
+        params.count = uint32(decodedCount);
+    }
+}

package/src/Xcm/v5/WildFungibility/WildFungibility.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+/// @notice Classification of whether an asset is fungible or not.
+enum WildFungibility {
+    /// @custom:variant The asset is fungible.
+    Fungible,
+    /// @custom:variant The asset is not fungible.
+    NonFungible
+}

package/src/Xcm/v5/WildFungibility/WildFungibilityCodec.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {WildFungibility} from "./WildFungibility.sol";
+
+/// @title SCALE Codec for XCM v5 `WildFungibility`
+/// @notice SCALE-compliant encoder/decoder for the `WildFungibility` 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 WildFungibilityCodec {
+    error InvalidWildFungibilityLength(uint256 length);
+    error InvalidWildFungibilityType(uint8 fType);
+
+    /// @notice Encodes a `WildFungibility` value into bytes.
+    /// @param wildFungibility The `WildFungibility` value to encode.
+    /// @return SCALE-encoded byte sequence representing the `WildFungibility`.
+    function encode(
+        WildFungibility wildFungibility
+    ) internal pure returns (bytes memory) {
+        return abi.encodePacked(uint8(wildFungibility));
+    }
+
+    /// @notice Returns the number of bytes that a `WildFungibility` value would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `WildFungibility`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `WildFungibility`.
+    /// @return The number of bytes that the `WildFungibility` value would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (offset >= data.length) {
+            revert InvalidWildFungibilityLength(data.length - offset);
+        }
+        return 1;
+    }
+
+    /// @notice Decodes a `WildFungibility` value from bytes starting at the beginning of the data.
+    /// @param data The byte sequence containing the encoded `WildFungibility`.
+    /// @return wildFungibility The decoded `WildFungibility` value.
+    /// @return bytesRead The total number of bytes read from `data` to decode the `WildFungibility`.
+    function decode(
+        bytes memory data
+    )
+        internal
+        pure
+        returns (WildFungibility wildFungibility, uint256 bytesRead)
+    {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes a `WildFungibility` value from bytes starting at a given offset.
+    /// @param data The byte sequence containing the encoded `WildFungibility`.
+    /// @param offset The starting index in `data` from which to decode the `WildFungibility`.
+    /// @return wildFungibility The decoded `WildFungibility` value.
+    /// @return bytesRead The total number of bytes read from `data` to decode the `WildFungibility`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    )
+        internal
+        pure
+        returns (WildFungibility wildFungibility, uint256 bytesRead)
+    {
+        if (offset >= data.length) {
+            revert InvalidWildFungibilityLength(data.length - offset);
+        }
+        uint8 fType = uint8(data[offset]);
+        if (fType > uint8(WildFungibility.NonFungible)) {
+            revert InvalidWildFungibilityType(fType);
+        }
+        wildFungibility = WildFungibility(fType);
+        bytesRead = 1;
+    }
+}

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

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Instruction} from "../Instruction/Instruction.sol";
+
+/// @notice Cross-Consensus Message: an ordered list of XCM v5 instructions.
+/// @dev Solidity representation of Rust `Xcm<Call>(Vec<Instruction<Call>>)`. In this package,
+/// the `Call` generic is represented as pre-encoded bytes inside `Instruction` payloads.
+struct Xcm {
+    /// @custom:property Ordered instructions that compose the XCM program.
+    Instruction[] instructions;
+}
+
+/// @notice Creates an empty `Xcm` instance.
+/// @return An `Xcm` value with no instructions.
+function newXcm() pure returns (Xcm memory) {
+    return Xcm({instructions: new Instruction[](0)});
+}
+
+/// @notice Creates an `Xcm` from an instruction array.
+/// @param instructions The ordered instruction list.
+/// @return An `Xcm` wrapper around `instructions`.
+function fromInstructions(
+    Instruction[] memory instructions
+) pure returns (Xcm memory) {
+    return Xcm({instructions: instructions});
+}

package/src/Xcm/v5/Xcm/XcmCodec.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Compact} from "../../../Scale/Compact.sol";
+import {Instruction} from "../Instruction/Instruction.sol";
+import {InstructionCodec} from "../Instruction/InstructionCodec.sol";
+import {Xcm} from "./Xcm.sol";
+
+/// @title SCALE Codec for XCM v5 `Xcm`
+/// @notice SCALE-compliant encoder/decoder for the `Xcm` type.
+/// @dev Rust parity: `Xcm<Call>(Vec<Instruction<Call>>)`, encoded as Compact length followed by each encoded instruction.
+library XcmCodec {
+    error InvalidXcmLength();
+
+    /// @notice Encodes an `Xcm` into SCALE bytes.
+    /// @param xcm The `Xcm` value to encode.
+    /// @return SCALE-encoded byte sequence representing `xcm`.
+    function encode(Xcm memory xcm) internal pure returns (bytes memory) {
+        bytes memory encoded = Compact.encode(xcm.instructions.length);
+        for (uint256 i = 0; i < xcm.instructions.length; i++) {
+            encoded = abi.encodePacked(
+                encoded,
+                InstructionCodec.encode(xcm.instructions[i])
+            );
+        }
+        return encoded;
+    }
+
+    /// @notice Returns the number of bytes that an `Xcm` occupies when SCALE-encoded.
+    /// @param data The byte sequence containing encoded `Xcm`.
+    /// @param offset The starting index in `data` from which to calculate size.
+    /// @return The number of bytes occupied by encoded `Xcm`.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (offset >= data.length) revert InvalidXcmLength();
+
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        uint256 pos = offset + prefixSize;
+
+        for (uint256 i = 0; i < count; i++) {
+            pos += InstructionCodec.encodedSizeAt(data, pos);
+        }
+
+        return pos - offset;
+    }
+
+    /// @notice Decodes an `Xcm` from SCALE bytes starting at the beginning.
+    /// @param data The byte sequence containing encoded `Xcm`.
+    /// @return xcm The decoded `Xcm` value.
+    /// @return bytesRead The number of bytes read.
+    function decode(
+        bytes memory data
+    ) internal pure returns (Xcm memory xcm, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `Xcm` from SCALE bytes starting at a given offset.
+    /// @param data The byte sequence containing encoded `Xcm`.
+    /// @param offset The starting index in `data` from which to decode.
+    /// @return xcm The decoded `Xcm` value.
+    /// @return bytesRead The number of bytes read.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (Xcm memory xcm, uint256 bytesRead) {
+        if (offset >= data.length) revert InvalidXcmLength();
+
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, offset);
+        Instruction[] memory instructions = new Instruction[](count);
+        uint256 pos = offset + prefixSize;
+
+        for (uint256 i = 0; i < count; i++) {
+            uint256 read;
+            (instructions[i], read) = InstructionCodec.decodeAt(data, pos);
+            pos += read;
+        }
+
+        xcm = Xcm({instructions: instructions});
+        bytesRead = pos - offset;
+    }
+}

package/src/Xcm/v5/XcmError/XcmError.sol

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {LittleEndianU64} from "../../../LittleEndian/LittleEndianU64.sol";
+
+/// @notice Error codes used in XCM.
+enum XcmErrorType {
+    /// @custom:variant An arithmetic overflow happened.
+    Overflow,
+    /// @custom:variant The instruction is intentionally unsupported.
+    Unimplemented,
+    /// @custom:variant Origin Register does not contain a valid value for a reserve transfer notification.
+    UntrustedReserveLocation,
+    /// @custom:variant Origin Register does not contain a valid value for a teleport notification.
+    UntrustedTeleportLocation,
+    /// @custom:variant `MultiLocation` value too large to descend further.
+    LocationFull,
+    /// @custom:variant `MultiLocation` value ascends more parents than known ancestors of local location.
+    LocationNotInvertible,
+    /// @custom:variant The Origin Register does not contain a valid value for the instruction.
+    BadOrigin,
+    /// @custom:variant The location parameter is not a valid value for the instruction.
+    InvalidLocation,
+    /// @custom:variant The given asset is not handled.
+    AssetNotFound,
+    /// @custom:variant An asset transaction failed, typically due to type conversions. NOTE: The string field is #[codec(skip)] and not serialized.
+    FailedToTransactAsset,
+    /// @custom:variant An asset cannot be withdrawn, potentially due to lack of ownership, availability or rights.
+    NotWithdrawable,
+    /// @custom:variant An asset cannot be deposited under the ownership of a particular location.
+    LocationCannotHold,
+    /// @custom:variant Attempt to send a message greater than the maximum supported by the transport protocol.
+    ExceedsMaxMessageSize,
+    /// @custom:variant The given message cannot be translated into a format supported by the destination.
+    DestinationUnsupported,
+    /// @custom:variant Destination is routable, but there is some issue with the transport mechanism. NOTE: The string field is #[codec(skip)] and not serialized.
+    Transport,
+    /// @custom:variant Destination is known to be unroutable.
+    Unroutable,
+    /// @custom:variant Used by `ClaimAsset` when the given claim could not be recognized/found.
+    UnknownClaim,
+    /// @custom:variant Used by `Transact` when the functor cannot be decoded.
+    FailedToDecode,
+    /// @custom:variant Used by `Transact` to indicate that the given weight limit could be breached by the functor.
+    MaxWeightInvalid,
+    /// @custom:variant Used by `BuyExecution` when the Holding Register does not contain payable fees.
+    NotHoldingFees,
+    /// @custom:variant Used by `BuyExecution` when the fees declared to purchase weight are insufficient.
+    TooExpensive,
+    /// @custom:variant Used by the `Trap` instruction to force an error intentionally.
+    Trap,
+    /// @custom:variant Used by `ExpectAsset`, `ExpectError` and `ExpectOrigin` when the expectation was not true.
+    ExpectationFalse,
+    /// @custom:variant The provided pallet index was not found.
+    PalletNotFound,
+    /// @custom:variant The given pallet's name is different to that expected.
+    NameMismatch,
+    /// @custom:variant The given pallet's version has an incompatible version to that expected.
+    VersionIncompatible,
+    /// @custom:variant The given operation would lead to an overflow of the Holding Register.
+    HoldingWouldOverflow,
+    /// @custom:variant The message was unable to be exported.
+    ExportError,
+    /// @custom:variant `MultiLocation` value failed to be reanchored.
+    ReanchorFailed,
+    /// @custom:variant No deal is possible under the given constraints.
+    NoDeal,
+    /// @custom:variant Fees were required which the origin could not pay.
+    FeesNotMet,
+    /// @custom:variant Some other error with locking.
+    LockError,
+    /// @custom:variant The state was not in a condition where the operation was valid to make.
+    NoPermission,
+    /// @custom:variant The universal location of the local consensus is improper.
+    Unanchored,
+    /// @custom:variant An asset cannot be deposited, probably because too much of it already exists.
+    NotDepositable,
+    /// @custom:variant Too many assets matched the given asset filter.
+    TooManyAssets
+}
+
+/// @notice XCM v5 error, containing the error type and an optional payload for `Trap`.
+struct XcmError {
+    /// @custom:property The type of the error. See `XcmErrorType` enum for possible values.
+    XcmErrorType eType;
+    /// @custom:property The trap code. Only meaningful when `eType` is `Trap`.
+    bytes payload;
+}
+
+/// @notice Parameters for unit (payload-less) XCM errors.
+struct UnitParams {
+    /// @custom:property The non-trap error discriminant.
+    XcmErrorType eType;
+}
+
+/// @notice Parameters for the `Trap` error variant.
+struct TrapParams {
+    /// @custom:property Trap code.
+    uint64 code;
+}
+
+using LittleEndianU64 for uint64;
+
+// ============ Factory Functions ============
+
+/// @notice Creates a unit `XcmError` with no payload.
+/// @param params Parameters for the unit error.
+/// @return The `XcmError` struct.
+function unit(UnitParams memory params) pure returns (XcmError memory) {
+    return XcmError({eType: params.eType, payload: ""});
+}
+
+/// @notice Creates a `Trap` error with the given u64 code.
+/// @param params Parameters for the trap error.
+/// @return The `XcmError` struct representing the trap.
+function trap(TrapParams memory params) pure returns (XcmError memory) {
+    return
+        XcmError({
+            eType: XcmErrorType.Trap,
+            payload: abi.encodePacked(params.code.toLittleEndian())
+        });
+}

package/src/Xcm/v5/XcmError/XcmErrorCodec.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {LittleEndianU64} from "../../../LittleEndian/LittleEndianU64.sol";
+import {XcmError, XcmErrorType} from "./XcmError.sol";
+
+/// @title SCALE Codec for XCM v5 `Error`
+/// @notice SCALE-compliant encoder/decoder for the XCM v5 `Error` 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/traits.rs.html
+library XcmErrorCodec {
+    error InvalidXcmErrorLength();
+    error InvalidXcmError(uint8 e);
+    error InvalidXcmErrorPayload();
+
+    /// @notice Encodes an `XcmError` into SCALE bytes.
+    /// @param e The `XcmError` struct to encode.
+    /// @return SCALE-encoded bytes representing the error.
+    function encode(XcmError memory e) internal pure returns (bytes memory) {
+        return abi.encodePacked(uint8(e.eType), e.payload);
+    }
+
+    /// @notice Returns the number of bytes that an `XcmError` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `XcmError`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size.
+    /// @return The number of bytes occupied by the encoded `XcmError`.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (data.length < offset + 1) revert InvalidXcmErrorLength();
+        uint8 raw = uint8(data[offset]);
+        if (raw > uint8(XcmErrorType.TooManyAssets))
+            revert InvalidXcmError(raw);
+        if (raw == uint8(XcmErrorType.Trap)) {
+            if (data.length < offset + 9) revert InvalidXcmErrorLength();
+            return 1 + 8; // 1 byte for the error type and 8 bytes for the u64 trap code
+        }
+        return 1;
+    }
+
+    /// @notice Decodes an `XcmError` from SCALE bytes starting at the beginning.
+    /// @param data The byte sequence containing the encoded `XcmError`.
+    /// @return e The decoded `XcmError` struct.
+    /// @return bytesRead The number of bytes read.
+    function decode(
+        bytes memory data
+    ) internal pure returns (XcmError memory e, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `XcmError` from SCALE bytes starting at a given offset.
+    /// @param data The byte sequence containing the encoded `XcmError`.
+    /// @param offset The starting index in `data` from which to decode.
+    /// @return e The decoded `XcmError` struct.
+    /// @return bytesRead The number of bytes read.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (XcmError memory e, uint256 bytesRead) {
+        if (data.length < offset + 1) revert InvalidXcmErrorLength();
+        uint8 raw = uint8(data[offset]);
+        if (raw > uint8(XcmErrorType.TooManyAssets))
+            revert InvalidXcmError(raw);
+        uint256 size = encodedSizeAt(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];
+        }
+        e = XcmError({eType: XcmErrorType(raw), payload: payload});
+        bytesRead = size;
+    }
+
+    /// @notice Decodes the trap code from a `Trap` error.
+    /// @param e The `XcmError` struct to decode, which must be of type `Trap`.
+    /// @return code The decoded u64 trap code.
+    function asTrap(XcmError memory e) internal pure returns (uint64 code) {
+        if (e.eType != XcmErrorType.Trap)
+            revert InvalidXcmError(uint8(e.eType));
+        if (e.payload.length != 8) revert InvalidXcmErrorPayload();
+        uint256 decoded = LittleEndianU64.fromLittleEndian(e.payload, 0);
+        code = uint64(decoded);
+    }
+}