solidity-scale-codec 0.3.4 → 1.0.1

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

@@ -4,7 +4,7 @@ pragma solidity ^0.8.28;
 import {LittleEndianU64} from "../../../LittleEndian/LittleEndianU64.sol";
 
 /// @notice Error codes used in XCM.
-enum XcmErrorType {
+enum XcmErrorVariant {
     /// @custom:variant An arithmetic overflow happened.
     Overflow,
     /// @custom:variant The instruction is intentionally unsupported.
@@ -81,16 +81,16 @@ enum XcmErrorType {
 
 /// @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`.
+    /// @custom:property The type of the error. See `XcmErrorVariant` enum for possible values.
+    XcmErrorVariant variant;
+    /// @custom:property The trap code. Only meaningful when `variant` is `Trap`.
     bytes payload;
 }
 
 /// @notice Parameters for unit (payload-less) XCM errors.
 struct UnitParams {
     /// @custom:property The non-trap error discriminant.
-    XcmErrorType eType;
+    XcmErrorVariant variant;
 }
 
 /// @notice Parameters for the `Trap` error variant.
@@ -107,7 +107,7 @@ using LittleEndianU64 for uint64;
 /// @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: ""});
+    return XcmError({variant: params.variant, payload: ""});
 }
 
 /// @notice Creates a `Trap` error with the given u64 code.
@@ -116,7 +116,7 @@ function unit(UnitParams memory params) pure returns (XcmError memory) {
 function trap(TrapParams memory params) pure returns (XcmError memory) {
     return
         XcmError({
-            eType: XcmErrorType.Trap,
+            variant: XcmErrorVariant.Trap,
             payload: abi.encodePacked(params.code.toLittleEndian())
         });
 }

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

@@ -2,7 +2,8 @@
 pragma solidity ^0.8.28;
 
 import {LittleEndianU64} from "../../../LittleEndian/LittleEndianU64.sol";
-import {XcmError, XcmErrorType} from "./XcmError.sol";
+import {XcmError, XcmErrorVariant, TrapParams} from "./XcmError.sol";
+import {BytesUtils} from "../../../Utils/BytesUtils.sol";
 
 /// @title SCALE Codec for XCM v5 `Error`
 /// @notice SCALE-compliant encoder/decoder for the XCM v5 `Error` type.
@@ -10,14 +11,14 @@ import {XcmError, XcmErrorType} from "./XcmError.sol";
 /// @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 InvalidXcmErrorVariant(uint8 variant);
     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);
+        return abi.encodePacked(uint8(e.variant), e.payload);
     }
 
     /// @notice Returns the number of bytes that an `XcmError` would occupy when SCALE-encoded.
@@ -30,9 +31,9 @@ library XcmErrorCodec {
     ) 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 (raw > uint8(type(XcmErrorVariant).max))
+            revert InvalidXcmErrorVariant(raw);
+        if (raw == uint8(XcmErrorVariant.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
         }
@@ -58,28 +59,30 @@ library XcmErrorCodec {
         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);
+        uint8 raw = 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];
-        }
-        e = XcmError({eType: XcmErrorType(raw), payload: payload});
+        bytes memory payload = BytesUtils.copy(data, offset + 1, payloadLength);
+        e = XcmError({variant: XcmErrorVariant(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);
+    /// @return params A `TrapParams` struct containing the decoded trap code.
+    function asTrap(
+        XcmError memory e
+    ) internal pure returns (TrapParams memory params) {
+        _assertVariant(e, XcmErrorVariant.Trap);
+        params.code = LittleEndianU64.fromLittleEndian(e.payload, 0);
+    }
+
+    function _assertVariant(
+        XcmError memory e,
+        XcmErrorVariant expected
+    ) internal pure {
+        if (e.variant != expected) {
+            revert InvalidXcmErrorVariant(uint8(e.variant));
+        }
     }
 }