solidity-scale-codec 0.3.4 → 1.0.0

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

@@ -3,7 +3,12 @@ pragma solidity ^0.8.28;
 
 import {Weight} from "../Weight/Weight.sol";
 import {WeightCodec} from "../Weight/WeightCodec.sol";
-import {WeightLimit, WeightLimitType} from "./WeightLimit.sol";
+import {
+    WeightLimit,
+    WeightLimitVariant,
+    LimitedParams
+} from "./WeightLimit.sol";
+import {BytesUtils} from "../../../Utils/BytesUtils.sol";
 
 /// @title SCALE Codec for XCM v5 `WeightLimit`
 /// @notice SCALE-compliant encoder/decoder for the `WeightLimit` type.
@@ -11,7 +16,7 @@ import {WeightLimit, WeightLimitType} from "./WeightLimit.sol";
 /// @dev XCM v5 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v5/enum.WeightLimit.html
 library WeightLimitCodec {
     error InvalidWeightLimitLength();
-    error InvalidWeightLimitType(uint8 wlType);
+    error InvalidWeightLimitVariant(uint8 variant);
 
     /// @notice Encodes a `WeightLimit` struct into SCALE bytes.
     /// @param wl The `WeightLimit` struct to encode.
@@ -19,7 +24,7 @@ library WeightLimitCodec {
     function encode(
         WeightLimit memory wl
     ) internal pure returns (bytes memory) {
-        return abi.encodePacked(uint8(wl.wlType), wl.payload);
+        return abi.encodePacked(uint8(wl.variant), wl.payload);
     }
 
     /// @notice Returns the number of bytes that a `WeightLimit` would occupy when SCALE-encoded.
@@ -31,13 +36,13 @@ library WeightLimitCodec {
         uint256 offset
     ) internal pure returns (uint256) {
         if (data.length < offset + 1) revert InvalidWeightLimitLength();
-        uint8 wlType = uint8(data[offset]);
-        if (wlType == uint8(WeightLimitType.Unlimited)) {
+        uint8 variant = uint8(data[offset]);
+        if (variant == uint8(WeightLimitVariant.Unlimited)) {
             return 1;
-        } else if (wlType == uint8(WeightLimitType.Limited)) {
+        } else if (variant == uint8(WeightLimitVariant.Limited)) {
             return 1 + WeightCodec.encodedSizeAt(data, offset + 1);
         } else {
-            revert InvalidWeightLimitType(wlType);
+            revert InvalidWeightLimitVariant(variant);
         }
     }
 
@@ -60,29 +65,33 @@ library WeightLimitCodec {
         bytes memory data,
         uint256 offset
     ) internal pure returns (WeightLimit memory wl, uint256 bytesRead) {
-        if (data.length < offset + 1) revert InvalidWeightLimitLength();
-        uint8 wlType = uint8(data[offset]);
-        if (wlType > uint8(WeightLimitType.Limited))
-            revert InvalidWeightLimitType(wlType);
         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];
-        }
-        wl = WeightLimit({wlType: WeightLimitType(wlType), payload: payload});
+        bytes memory payload = BytesUtils.copy(data, offset + 1, payloadLength);
+        wl = WeightLimit({
+            variant: WeightLimitVariant(variant),
+            payload: payload
+        });
         bytesRead = size;
     }
 
     /// @notice Decodes the `Weight` from a `Limited` weight limit.
     /// @param wl The `WeightLimit` struct. Must be of type `Limited`.
-    /// @return The decoded `Weight`.
-    function asWeight(
+    /// @return params A `LimitedParams` struct containing the decoded weight.
+    function asLimited(
         WeightLimit memory wl
-    ) internal pure returns (Weight memory) {
-        if (wl.wlType != WeightLimitType.Limited)
-            revert InvalidWeightLimitType(uint8(wl.wlType));
-        (Weight memory w, ) = WeightCodec.decode(wl.payload);
-        return w;
+    ) internal pure returns (LimitedParams memory params) {
+        _assertVariant(wl, WeightLimitVariant.Limited);
+        (params.weight, ) = WeightCodec.decode(wl.payload);
+    }
+
+    function _assertVariant(
+        WeightLimit memory wl,
+        WeightLimitVariant expected
+    ) internal pure {
+        if (wl.variant != expected) {
+            revert InvalidWeightLimitVariant(uint8(wl.variant));
+        }
     }
 }

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

@@ -8,7 +8,7 @@ import {WildFungibility} from "../WildFungibility/WildFungibility.sol";
 import {WildFungibilityCodec} from "../WildFungibility/WildFungibilityCodec.sol";
 
 /// @notice Discriminant for the type of asset being specified in a `WildAsset`.
-enum WildAssetType {
+enum WildAssetVariant {
     /// @custom:variant All assets in Holding.
     All,
     /// @custom:variant All assets in Holding of a given fungibility and ID.
@@ -45,9 +45,9 @@ struct AllCountedParams {
 
 /// @notice A wildcard representing a set of assets.
 struct WildAsset {
-    /// @custom:property The type of wild asset, determining how to interpret the payload. See `WildAssetType` enum for possible values.
-    WildAssetType waType;
-    /// @custom:property The encoded payload containing the wild asset data, whose structure depends on the `waType`.
+    /// @custom:property The type of wild asset, determining how to interpret the payload. See `WildAssetVariant` enum for possible values.
+    WildAssetVariant variant;
+    /// @custom:property The encoded payload containing the wild asset data, whose structure depends on the `variant`.
     bytes payload;
 }
 
@@ -56,23 +56,19 @@ struct WildAsset {
 /// @notice Creates a `WildAsset` struct representing the `All` variant, which matches all assets in Holding.
 /// @return A `WildAsset` with the `All` variant.
 function all() pure returns (WildAsset memory) {
-    return WildAsset({waType: WildAssetType.All, payload: ""});
+    return WildAsset({variant: WildAssetVariant.All, payload: ""});
 }
 
 /// @notice Creates a `WildAsset` struct representing the `AllOf` variant, which matches all assets in Holding of a given fungibility and ID.
-/// @param id The `AssetId` struct specifying the asset class to match against.
-/// @param fun The `WildFungibility` struct specifying the fungibility to match against.
+/// @param params Parameters for the all-of variant.
 /// @return A `WildAsset` with the `AllOf` variant and the encoded parameters in the payload.
-function allOf(
-    AssetId memory id,
-    WildFungibility fun
-) pure returns (WildAsset memory) {
+function allOf(AllOfParams memory params) pure returns (WildAsset memory) {
     return
         WildAsset({
-            waType: WildAssetType.AllOf,
+            variant: WildAssetVariant.AllOf,
             payload: abi.encodePacked(
-                AssetIdCodec.encode(id),
-                WildFungibilityCodec.encode(fun)
+                AssetIdCodec.encode(params.id),
+                WildFungibilityCodec.encode(params.fun)
             )
         });
 }
@@ -85,28 +81,24 @@ function allCounted(
 ) pure returns (WildAsset memory) {
     return
         WildAsset({
-            waType: WildAssetType.AllCounted,
+            variant: WildAssetVariant.AllCounted,
             payload: abi.encodePacked(Compact.encode(params.count))
         });
 }
 
 /// @notice Creates a `WildAsset` struct representing the `AllOfCounted` variant, which matches all assets in Holding of a given fungibility and ID up to `count` individual assets (different instances of non-fungibles are separate assets).
-/// @param id The `AssetId` struct specifying the asset class to match against.
-/// @param fun The `WildFungibility` struct specifying the fungibility to match against.
-/// @param count The limit of assets  against.
+/// @param params Parameters for the all-of-counted variant.
 /// @return A `WildAsset` with the `AllOfCounted` variant and the encoded parameters in the payload.
 function allOfCounted(
-    AssetId memory id,
-    WildFungibility fun,
-    uint32 count
+    AllOfCountedParams memory params
 ) pure returns (WildAsset memory) {
     return
         WildAsset({
-            waType: WildAssetType.AllOfCounted,
+            variant: WildAssetVariant.AllOfCounted,
             payload: abi.encodePacked(
-                AssetIdCodec.encode(id),
-                WildFungibilityCodec.encode(fun),
-                Compact.encode(count)
+                AssetIdCodec.encode(params.id),
+                WildFungibilityCodec.encode(params.fun),
+                Compact.encode(params.count)
             )
         });
 }

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

@@ -8,10 +8,13 @@ import {AssetId} from "../AssetId/AssetId.sol";
 import {WildFungibility} from "../WildFungibility/WildFungibility.sol";
 import {
     WildAsset,
-    WildAssetType,
+    WildAssetVariant,
     AllOfParams,
+    AllCountedParams,
     AllOfCountedParams
 } from "./WildAsset.sol";
+import {BytesUtils} from "../../../Utils/BytesUtils.sol";
+import {UnsignedUtils} from "../../../Utils/UnsignedUtils.sol";
 
 /// @title SCALE Codec for XCM v5 `WildAsset`
 /// @notice SCALE-compliant encoder/decoder for the `WildAsset` type.
@@ -19,7 +22,7 @@ import {
 /// @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 InvalidWildAssetVariant(uint8 variant);
     error InvalidWildAssetPayload();
 
     /// @notice Encodes a `WildAsset` struct into bytes.
@@ -28,7 +31,7 @@ library WildAssetCodec {
     function encode(
         WildAsset memory wildAsset
     ) internal pure returns (bytes memory) {
-        return abi.encodePacked(uint8(wildAsset.waType), wildAsset.payload);
+        return abi.encodePacked(uint8(wildAsset.variant), wildAsset.payload);
     }
 
     /// @notice Returns the number of bytes that a `WildAsset` struct would occupy when SCALE-encoded.
@@ -42,21 +45,21 @@ library WildAssetCodec {
         if (offset >= data.length) {
             revert InvalidWildAssetLength();
         }
-        uint8 waType = uint8(data[offset]);
-        if (waType > uint8(WildAssetType.AllOfCounted)) {
-            revert InvalidWildAssetType(waType);
+        uint8 variant = uint8(data[offset]);
+        if (variant > uint8(WildAssetVariant.AllOfCounted)) {
+            revert InvalidWildAssetVariant(variant);
         }
         uint256 payloadLength;
-        if (waType == uint8(WildAssetType.All)) {
+        if (variant == uint8(WildAssetVariant.All)) {
             payloadLength = 0;
-        } else if (waType == uint8(WildAssetType.AllOf)) {
+        } else if (variant == uint8(WildAssetVariant.AllOf)) {
             uint256 idSize = AssetIdCodec.encodedSizeAt(data, offset + 1);
             payloadLength =
                 idSize +
                 WildFungibilityCodec.encodedSizeAt(data, offset + 1 + idSize);
-        } else if (waType == uint8(WildAssetType.AllCounted)) {
+        } else if (variant == uint8(WildAssetVariant.AllCounted)) {
             payloadLength = Compact.encodedSizeAt(data, offset + 1);
-        } else if (waType == uint8(WildAssetType.AllOfCounted)) {
+        } else if (variant == uint8(WildAssetVariant.AllOfCounted)) {
             uint256 idSize = AssetIdCodec.encodedSizeAt(data, offset + 1);
             uint256 funSize = WildFungibilityCodec.encodedSizeAt(
                 data,
@@ -67,9 +70,9 @@ library WildAssetCodec {
                 funSize +
                 Compact.encodedSizeAt(data, offset + 1 + idSize + funSize);
         } else {
-            revert InvalidWildAssetType(waType);
+            revert InvalidWildAssetVariant(variant);
         }
-        return 1 + payloadLength; // 1 byte for the waType
+        return 1 + payloadLength; // 1 byte for the variant
     }
 
     /// @notice Decodes a `WildAsset` instance from bytes starting at the beginning of the data.
@@ -91,19 +94,10 @@ library WildAssetCodec {
         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];
-        }
+        uint256 payloadLength = encodedSizeAt(data, offset) - 1; // subtract 1 byte for the variant
+        uint8 variant = uint8(data[offset]);
+        wildAsset.variant = WildAssetVariant(variant);
+        wildAsset.payload = BytesUtils.copy(data, offset + 1, payloadLength);
         bytesRead = 1 + payloadLength;
     }
 
@@ -113,9 +107,7 @@ library WildAssetCodec {
     function asAllOf(
         WildAsset memory wildAsset
     ) internal pure returns (AllOfParams memory params) {
-        if (wildAsset.waType != WildAssetType.AllOf) {
-            revert InvalidWildAssetType(uint8(wildAsset.waType));
-        }
+        _assertVariant(wildAsset, WildAssetVariant.AllOf);
         uint256 bytesRead;
         (params.id, bytesRead) = AssetIdCodec.decode(wildAsset.payload);
         (params.fun, ) = WildFungibilityCodec.decodeAt(
@@ -126,16 +118,14 @@ library WildAssetCodec {
 
     /// @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.
+    /// @return params An `AllCountedParams` struct containing the decoded parameters from the payload, including the count limit.
     function asAllCounted(
         WildAsset memory wildAsset
-    ) internal pure returns (uint32 count) {
-        if (wildAsset.waType != WildAssetType.AllCounted) {
-            revert InvalidWildAssetType(uint8(wildAsset.waType));
-        }
+    ) internal pure returns (AllCountedParams memory params) {
+        _assertVariant(wildAsset, WildAssetVariant.AllCounted);
         uint256 decodedCount;
         (decodedCount, ) = Compact.decode(wildAsset.payload);
-        count = uint32(decodedCount);
+        params.count = UnsignedUtils.toU32(decodedCount);
     }
 
     /// @notice Decodes the parameters of a `WildAsset` with the `AllOfCounted` variant from its payload.
@@ -144,9 +134,7 @@ library WildAssetCodec {
     function asAllOfCounted(
         WildAsset memory wildAsset
     ) internal pure returns (AllOfCountedParams memory params) {
-        if (wildAsset.waType != WildAssetType.AllOfCounted) {
-            revert InvalidWildAssetType(uint8(wildAsset.waType));
-        }
+        _assertVariant(wildAsset, WildAssetVariant.AllOfCounted);
         uint256 offset = 0;
         uint256 bytesRead;
         (params.id, bytesRead) = AssetIdCodec.decodeAt(
@@ -161,6 +149,15 @@ library WildAssetCodec {
         offset += bytesRead;
         uint256 decodedCount;
         (decodedCount, ) = Compact.decodeAt(wildAsset.payload, offset);
-        params.count = uint32(decodedCount);
+        params.count = UnsignedUtils.toU32(decodedCount);
+    }
+
+    function _assertVariant(
+        WildAsset memory wildAsset,
+        WildAssetVariant expected
+    ) internal pure {
+        if (wildAsset.variant != expected) {
+            revert InvalidWildAssetVariant(uint8(wildAsset.variant));
+        }
     }
 }

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

@@ -8,8 +8,8 @@ import {WildFungibility} from "./WildFungibility.sol";
 /// @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);
+    error InvalidWildFungibilityLength();
+    error InvalidWildFungibility(uint8 fType);
 
     /// @notice Encodes a `WildFungibility` value into bytes.
     /// @param wildFungibility The `WildFungibility` value to encode.
@@ -29,7 +29,7 @@ library WildFungibilityCodec {
         uint256 offset
     ) internal pure returns (uint256) {
         if (offset >= data.length) {
-            revert InvalidWildFungibilityLength(data.length - offset);
+            revert InvalidWildFungibilityLength();
         }
         return 1;
     }
@@ -62,11 +62,11 @@ library WildFungibilityCodec {
         returns (WildFungibility wildFungibility, uint256 bytesRead)
     {
         if (offset >= data.length) {
-            revert InvalidWildFungibilityLength(data.length - offset);
+            revert InvalidWildFungibilityLength();
         }
         uint8 fType = uint8(data[offset]);
-        if (fType > uint8(WildFungibility.NonFungible)) {
-            revert InvalidWildFungibilityType(fType);
+        if (fType > uint8(type(WildFungibility).max)) {
+            revert InvalidWildFungibility(fType);
         }
         wildFungibility = WildFungibility(fType);
         bytesRead = 1;