solidity-scale-codec 0.3.4 → 1.0.1

package/src/Xcm/v5/BodyId/BodyIdCodec.sol

@@ -3,7 +3,9 @@ pragma solidity ^0.8.28;
 
 import {Bytes4} from "../../../Scale/Bytes.sol";
 import {Compact} from "../../../Scale/Compact.sol";
-import {BodyId, BodyIdType} from "./BodyId.sol";
+import {BodyId, BodyIdVariant, MonikerParams, IndexParams} from "./BodyId.sol";
+import {BytesUtils} from "../../../Utils/BytesUtils.sol";
+import {UnsignedUtils} from "../../../Utils/UnsignedUtils.sol";
 
 /// @title SCALE Codec for XCM v5 `BodyId`
 /// @notice SCALE-compliant encoder/decoder for the `BodyId` type.
@@ -11,13 +13,13 @@ import {BodyId, BodyIdType} from "./BodyId.sol";
 /// @dev XCM v5 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v5/index.html
 library BodyIdCodec {
     error InvalidBodyIdLength();
-    error InvalidBodyIdType(uint8 bodyIdType);
+    error InvalidBodyIdVariant(uint8 variant);
 
     /// @notice Encodes a `BodyId` into bytes.
     /// @param bodyId The `BodyId` to encode.
     /// @return SCALE-encoded byte sequence representing the `BodyId`.
     function encode(BodyId memory bodyId) internal pure returns (bytes memory) {
-        return abi.encodePacked(uint8(bodyId.bodyIdType), bodyId.payload);
+        return abi.encodePacked(uint8(bodyId.variant), bodyId.payload);
     }
 
     /// @notice Returns the number of bytes that a `BodyId` struct would occupy when SCALE-encoded, starting at a given offset in the data.
@@ -31,26 +33,26 @@ library BodyIdCodec {
         if (data.length < offset + 1) {
             revert InvalidBodyIdLength();
         }
-        uint8 bodyIdTypeValue = uint8(data[offset]);
-        BodyIdType bodyIdType = BodyIdType(bodyIdTypeValue);
+        uint8 variantValue = uint8(data[offset]);
+        BodyIdVariant variant = BodyIdVariant(variantValue);
         uint256 payloadLength;
         if (
-            bodyIdType == BodyIdType.Unit ||
-            bodyIdType == BodyIdType.Executive ||
-            bodyIdType == BodyIdType.Technical ||
-            bodyIdType == BodyIdType.Legislative ||
-            bodyIdType == BodyIdType.Judicial ||
-            bodyIdType == BodyIdType.Defense ||
-            bodyIdType == BodyIdType.Administration ||
-            bodyIdType == BodyIdType.Treasury
+            variant == BodyIdVariant.Unit ||
+            variant == BodyIdVariant.Executive ||
+            variant == BodyIdVariant.Technical ||
+            variant == BodyIdVariant.Legislative ||
+            variant == BodyIdVariant.Judicial ||
+            variant == BodyIdVariant.Defense ||
+            variant == BodyIdVariant.Administration ||
+            variant == BodyIdVariant.Treasury
         ) {
             payloadLength = 0;
-        } else if (bodyIdType == BodyIdType.Moniker) {
+        } else if (variant == BodyIdVariant.Moniker) {
             payloadLength = 4;
-        } else if (bodyIdType == BodyIdType.Index) {
+        } else if (variant == BodyIdVariant.Index) {
             payloadLength = 4;
         } else {
-            revert InvalidBodyIdType(bodyIdTypeValue);
+            revert InvalidBodyIdVariant(variantValue);
         }
 
         if (data.length < offset + 1 + payloadLength) {
@@ -79,50 +81,41 @@ library BodyIdCodec {
         bytes memory data,
         uint256 offset
     ) internal pure returns (BodyId memory bodyId, uint256 bytesRead) {
-        if (data.length < offset + 1) {
-            revert InvalidBodyIdLength();
-        }
-        uint8 bodyIdTypeValue = uint8(data[offset]);
-        BodyIdType bodyIdType = BodyIdType(bodyIdTypeValue);
-        uint256 payloadLength = encodedSizeAt(data, offset) - 1; // subtract 1 byte for the bodyIdType
-        bytes memory payload = new bytes(payloadLength);
-
-        for (uint256 i = 0; i < payloadLength; i++) {
-            payload[i] = data[offset + 1 + i];
-        }
-
-        bodyId = BodyId({bodyIdType: bodyIdType, payload: payload});
+        uint256 payloadLength = encodedSizeAt(data, offset) - 1; // subtract 1 byte for the variant
+        uint8 variantValue = uint8(data[offset]);
+        BodyIdVariant variant = BodyIdVariant(variantValue);
+        bytes memory payload = BytesUtils.copy(data, offset + 1, payloadLength);
+        bodyId = BodyId({variant: variant, payload: payload});
         bytesRead = 1 + payloadLength;
     }
 
     /// @notice Helper function to decode a `BodyId` and extract the moniker name if the type is `Moniker`.
     /// @param bodyId The `BodyId` to extract the moniker name from.
-    /// @return name The 4-byte name of the moniker if the `bodyIdType` is `Moniker`.
+    /// @return params A `MonikerParams` struct containing the moniker name if the `variant` is `Moniker`.
     function asMoniker(
         BodyId memory bodyId
-    ) internal pure returns (bytes4 name) {
-        if (bodyId.bodyIdType != BodyIdType.Moniker) {
-            revert InvalidBodyIdType(uint8(bodyId.bodyIdType));
-        }
-        return Bytes4.decode(bodyId.payload);
+    ) internal pure returns (MonikerParams memory params) {
+        _assertVariant(bodyId, BodyIdVariant.Moniker);
+        params.name = Bytes4.decode(bodyId.payload);
     }
 
     /// @notice Helper function to decode a `BodyId` and extract the index if the type is `Index`.
     /// @param bodyId The `BodyId` to extract the index from.
-    /// @return idx The index of the body if the `bodyIdType` is `Index`.
-    function asIndex(BodyId memory bodyId) internal pure returns (uint32 idx) {
-        if (bodyId.bodyIdType != BodyIdType.Index) {
-            revert InvalidBodyIdType(uint8(bodyId.bodyIdType));
-        }
-        if (bodyId.payload.length != 4) {
-            revert InvalidBodyIdLength();
-        }
+    /// @return params An `IndexParams` struct containing the index if the `variant` is `Index`.
+    function asIndex(
+        BodyId memory bodyId
+    ) internal pure returns (IndexParams memory params) {
+        _assertVariant(bodyId, BodyIdVariant.Index);
         (uint256 decodedIndex, ) = Compact.decode(bodyId.payload);
-        if (decodedIndex > type(uint32).max) {
-            revert InvalidBodyIdLength();
-        }
-        unchecked {
-            idx = uint32(decodedIndex);
+        params.index = UnsignedUtils.toU32(decodedIndex);
+    }
+
+    function _assertVariant(
+        BodyId memory bodyId,
+        BodyIdVariant expected
+    ) internal pure {
+        if (bodyId.variant != expected) {
+            revert InvalidBodyIdVariant(uint8(bodyId.variant));
         }
     }
 }

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

@@ -4,7 +4,7 @@ pragma solidity ^0.8.28;
 import {Compact} from "../../../Scale/Compact.sol";
 
 /// @dev Discriminant for the different types of BodyParts in XCM v5. Each variant corresponds to a specific structure of the payload.
-enum BodyPartType {
+enum BodyPartVariant {
     /// @custom:variant The body's declaration, under whatever means it decides.
     Voice,
     /// @custom:variant A given number of members of the body.
@@ -19,8 +19,8 @@ enum BodyPartType {
 
 /// @notice A part of a pluralistic body.
 struct BodyPart {
-    /// @custom:property The type of BodyPart, which determines how to interpret the payload. See `BodyPartType` enum for possible values.
-    BodyPartType bodyPartType;
+    /// @custom:property The type of BodyPart, which determines how to interpret the payload. See `BodyPartVariant` enum for possible values.
+    BodyPartVariant variant;
     /// @custom:property For Members, this will hold the count. For Fraction, AtLeastProportion, and MoreThanProportion, this will hold the encoded Proportion struct. For Voice, this will be empty.
     bytes payload;
 }
@@ -31,12 +31,36 @@ struct MembersParams {
     uint32 count;
 }
 
+/// @notice Parameters for the `Fraction` variant.
+struct FractionParams {
+    /// @custom:property The numerator of the fraction, representing the number of members in favor.
+    uint32 nominator;
+    /// @custom:property The denominator of the fraction, representing the total number of members considered.
+    uint32 denominator;
+}
+
+/// @notice Parameters for the `AtLeastProportion` variant.
+struct AtLeastProportionParams {
+    /// @custom:property The numerator of the proportion, representing the minimum number of members in favor.
+    uint32 nominator;
+    /// @custom:property The denominator of the proportion, representing the total number of members considered.
+    uint32 denominator;
+}
+
+/// @notice Parameters for the `MoreThanProportion` variant.
+struct MoreThanProportionParams {
+    /// @custom:property The numerator of the proportion, representing the minimum number of members in favor.
+    uint32 nominator;
+    /// @custom:property The denominator of the proportion, representing the total number of members considered.
+    uint32 denominator;
+}
+
 // ============ Factory Functions ============
 
 /// @notice Creates a `BodyPart` struct representing a `Voice` body part.
 /// @return A `BodyPart` with the `Voice` variant.
 function voice() pure returns (BodyPart memory) {
-    return BodyPart({bodyPartType: BodyPartType.Voice, payload: ""});
+    return BodyPart({variant: BodyPartVariant.Voice, payload: ""});
 }
 
 /// @notice Creates a `BodyPart` struct representing a `Members` body part with the given count.
@@ -45,61 +69,53 @@ function voice() pure returns (BodyPart memory) {
 function members(MembersParams memory params) pure returns (BodyPart memory) {
     return
         BodyPart({
-            bodyPartType: BodyPartType.Members,
+            variant: BodyPartVariant.Members,
             payload: Compact.encode(params.count)
         });
 }
 
 /// @notice Creates a `BodyPart` struct representing a `Fraction` body part with the given proportion.
-/// @param nominator The numerator of the proportion, representing the number of members in favor.
-/// @param denominator The denominator of the proportion, representing the total number of members considered.
+/// @param params Parameters for the fraction variant.
 /// @return A `BodyPart` with the `Fraction` variant and the encoded proportion in the payload.
-function fraction(
-    uint32 nominator,
-    uint32 denominator
-) pure returns (BodyPart memory) {
+function fraction(FractionParams memory params) pure returns (BodyPart memory) {
     return
         BodyPart({
-            bodyPartType: BodyPartType.Fraction,
+            variant: BodyPartVariant.Fraction,
             payload: abi.encodePacked(
-                Compact.encode(nominator),
-                Compact.encode(denominator)
+                Compact.encode(params.nominator),
+                Compact.encode(params.denominator)
             )
         });
 }
 
 /// @notice Creates a `BodyPart` struct representing an `AtLeastProportion` body part with the given proportion.
-/// @param nominator The numerator of the proportion, representing the minimum number of members in favor.
-/// @param denominator The denominator of the proportion, representing the total number of members considered.
+/// @param params Parameters for the at least proportion variant.
 /// @return A `BodyPart` with the `AtLeastProportion` variant and the encoded proportion in the payload.
 function atLeastProportion(
-    uint32 nominator,
-    uint32 denominator
+    AtLeastProportionParams memory params
 ) pure returns (BodyPart memory) {
     return
         BodyPart({
-            bodyPartType: BodyPartType.AtLeastProportion,
+            variant: BodyPartVariant.AtLeastProportion,
             payload: abi.encodePacked(
-                Compact.encode(nominator),
-                Compact.encode(denominator)
+                Compact.encode(params.nominator),
+                Compact.encode(params.denominator)
             )
         });
 }
 
 /// @notice Creates a `BodyPart` struct representing a `MoreThanProportion` body part with the given proportion.
-/// @param nominator The numerator of the proportion, representing the minimum number of members in favor.
-/// @param denominator The denominator of the proportion, representing the total number of members considered.
+/// @param params Parameters for the more than proportion variant.
 /// @return A `BodyPart` with the `MoreThanProportion` variant and the encoded proportion in the payload.
 function moreThanProportion(
-    uint32 nominator,
-    uint32 denominator
+    MoreThanProportionParams memory params
 ) pure returns (BodyPart memory) {
     return
         BodyPart({
-            bodyPartType: BodyPartType.MoreThanProportion,
+            variant: BodyPartVariant.MoreThanProportion,
             payload: abi.encodePacked(
-                Compact.encode(nominator),
-                Compact.encode(denominator)
+                Compact.encode(params.nominator),
+                Compact.encode(params.denominator)
             )
         });
 }

package/src/Xcm/v5/BodyPart/BodyPartCodec.sol

@@ -2,7 +2,16 @@
 pragma solidity ^0.8.28;
 
 import {Compact} from "../../../Scale/Compact.sol";
-import {BodyPart, BodyPartType} from "./BodyPart.sol";
+import {
+    BodyPart,
+    BodyPartVariant,
+    MembersParams,
+    FractionParams,
+    AtLeastProportionParams,
+    MoreThanProportionParams
+} from "./BodyPart.sol";
+import {BytesUtils} from "../../../Utils/BytesUtils.sol";
+import {UnsignedUtils} from "../../../Utils/UnsignedUtils.sol";
 
 /// @title SCALE Codec for XCM v5 `BodyPart`
 /// @notice SCALE-compliant encoder/decoder for the `BodyPart` type.
@@ -10,8 +19,7 @@ import {BodyPart, BodyPartType} from "./BodyPart.sol";
 /// @dev XCM v5 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v5/index.html
 library BodyPartCodec {
     error InvalidBodyPartLength();
-    error InvalidBodyPartType(uint8 bodyPartType);
-    error InvalidBodyPartPayload();
+    error InvalidBodyPartVariant(uint8 variant);
 
     /// @notice Encodes a `BodyPart` struct into bytes.
     /// @param bodyPart The `BodyPart` struct to encode.
@@ -19,7 +27,7 @@ library BodyPartCodec {
     function encode(
         BodyPart memory bodyPart
     ) internal pure returns (bytes memory) {
-        return abi.encodePacked(uint8(bodyPart.bodyPartType), bodyPart.payload);
+        return abi.encodePacked(uint8(bodyPart.variant), bodyPart.payload);
     }
 
     /// @notice Returns the number of bytes that a `BodyPart` struct would occupy when SCALE-encoded.
@@ -32,23 +40,23 @@ library BodyPartCodec {
     ) internal pure returns (uint256) {
         if (offset >= data.length) revert InvalidBodyPartLength();
 
-        uint8 bodyPartType = uint8(data[offset]);
+        uint8 variant = uint8(data[offset]);
         uint256 payloadLength;
-        if (bodyPartType == uint8(BodyPartType.Voice)) {
+        if (variant == uint8(BodyPartVariant.Voice)) {
             payloadLength = 0;
-        } else if (bodyPartType == uint8(BodyPartType.Members)) {
+        } else if (variant == uint8(BodyPartVariant.Members)) {
             payloadLength = Compact.encodedSizeAt(data, offset + 1);
         } else if (
-            bodyPartType == uint8(BodyPartType.Fraction) ||
-            bodyPartType == uint8(BodyPartType.AtLeastProportion) ||
-            bodyPartType == uint8(BodyPartType.MoreThanProportion)
+            variant == uint8(BodyPartVariant.Fraction) ||
+            variant == uint8(BodyPartVariant.AtLeastProportion) ||
+            variant == uint8(BodyPartVariant.MoreThanProportion)
         ) {
             uint256 innerLength = Compact.encodedSizeAt(data, offset + 1);
             payloadLength =
                 innerLength +
                 Compact.encodedSizeAt(data, offset + 1 + innerLength);
         } else {
-            revert InvalidBodyPartType(bodyPartType);
+            revert InvalidBodyPartVariant(variant);
         }
 
         if (data.length < offset + 1 + payloadLength) {
@@ -77,18 +85,13 @@ library BodyPartCodec {
         bytes memory data,
         uint256 offset
     ) internal pure returns (BodyPart memory bodyPart, uint256 bytesRead) {
-        if (offset >= data.length) revert InvalidBodyPartLength();
-
-        uint8 bodyPartType = uint8(data[offset]);
-        uint256 payloadLength = encodedSizeAt(data, offset) - 1; // total size minus 1 byte for the bodyPartType
+        uint256 payloadLength = encodedSizeAt(data, offset) - 1; // total size minus 1 byte for the variant
+        uint8 variant = uint8(data[offset]);
 
-        bytes memory payload = new bytes(payloadLength);
-        for (uint256 i = 0; i < payloadLength; i++) {
-            payload[i] = data[offset + 1 + i];
-        }
+        bytes memory payload = BytesUtils.copy(data, offset + 1, payloadLength);
 
         bodyPart = BodyPart({
-            bodyPartType: BodyPartType(bodyPartType),
+            variant: BodyPartVariant(variant),
             payload: payload
         });
         bytesRead = 1 + payloadLength;
@@ -96,31 +99,52 @@ library BodyPartCodec {
 
     /// @notice Decodes a `Members` body part to extract the member count.
     /// @param bodyPart The `BodyPart` struct to decode, which must be of type `Members`.
-    /// @return count The number of members encoded in the body part's payload.
+    /// @return params A `MembersParams` struct containing the member count encoded in the body part's payload.
     function asMembers(
         BodyPart memory bodyPart
-    ) internal pure returns (uint32 count) {
-        if (bodyPart.bodyPartType != BodyPartType.Members) {
-            revert InvalidBodyPartType(uint8(bodyPart.bodyPartType));
-        }
+    ) internal pure returns (MembersParams memory params) {
+        _assertVariant(bodyPart, BodyPartVariant.Members);
         (uint256 decodedCount, ) = Compact.decode(bodyPart.payload);
-        count = uint32(decodedCount);
+        params.count = UnsignedUtils.toU32(decodedCount);
+    }
+
+    /// @notice Decodes a `Fraction` body part to extract the nominator and denominator.
+    /// @param bodyPart The `BodyPart` struct to decode, which must be of type `Fraction`.
+    /// @return params A `FractionParams` struct containing the nominator and denominator encoded in the body part's payload.
+    function asFraction(
+        BodyPart memory bodyPart
+    ) internal pure returns (FractionParams memory params) {
+        _assertVariant(bodyPart, BodyPartVariant.Fraction);
+        (params.nominator, params.denominator) = _asProportion(bodyPart);
+    }
+
+    /// @notice Decodes a `AtLeastProportion` body part to extract the nominator and denominator.
+    /// @param bodyPart The `BodyPart` struct to decode, which must be of type `AtLeastProportion`.
+    /// @return params An `AtLeastProportionParams` struct containing the nominator and denominator encoded in the body part's payload.
+    function asAtLeastProportion(
+        BodyPart memory bodyPart
+    ) internal pure returns (AtLeastProportionParams memory params) {
+        _assertVariant(bodyPart, BodyPartVariant.AtLeastProportion);
+        (params.nominator, params.denominator) = _asProportion(bodyPart);
+    }
+
+    /// @notice Decodes a `MoreThanProportion` body part to extract the nominator and denominator.
+    /// @param bodyPart The `BodyPart` struct to decode, which must be of type `MoreThanProportion`.
+    /// @return params A `MoreThanProportionParams` struct containing the nominator and denominator encoded in the body part's payload.
+    function asMoreThanProportion(
+        BodyPart memory bodyPart
+    ) internal pure returns (MoreThanProportionParams memory params) {
+        _assertVariant(bodyPart, BodyPartVariant.MoreThanProportion);
+        (params.nominator, params.denominator) = _asProportion(bodyPart);
     }
 
     /// @notice Decodes a `Fraction`, `AtLeastProportion`, or `MoreThanProportion` body part to extract the nominator and denominator.
     /// @param bodyPart The `BodyPart` struct to decode, which must be of type `Fraction`, `AtLeastProportion`, or `MoreThanProportion`.
     /// @return nominator The numerator of the proportion encoded in the body part's payload.
     /// @return denominator The denominator of the proportion encoded in the body part's payload.
-    function asProportion(
+    function _asProportion(
         BodyPart memory bodyPart
-    ) internal pure returns (uint32 nominator, uint32 denominator) {
-        if (
-            bodyPart.bodyPartType != BodyPartType.Fraction &&
-            bodyPart.bodyPartType != BodyPartType.AtLeastProportion &&
-            bodyPart.bodyPartType != BodyPartType.MoreThanProportion
-        ) {
-            revert InvalidBodyPartType(uint8(bodyPart.bodyPartType));
-        }
+    ) private pure returns (uint32 nominator, uint32 denominator) {
         (uint256 decodedNominator, uint256 offset) = Compact.decode(
             bodyPart.payload
         );
@@ -128,7 +152,16 @@ library BodyPartCodec {
             bodyPart.payload,
             offset
         );
-        nominator = uint32(decodedNominator);
-        denominator = uint32(decodedDenominator);
+        nominator = UnsignedUtils.toU32(decodedNominator);
+        denominator = UnsignedUtils.toU32(decodedDenominator);
+    }
+
+    function _assertVariant(
+        BodyPart memory bodyPart,
+        BodyPartVariant expected
+    ) internal pure {
+        if (bodyPart.variant != expected) {
+            revert InvalidBodyPartVariant(uint8(bodyPart.variant));
+        }
     }
 }

package/src/Xcm/v5/Constants.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.28;
 
-import {HintType} from "./Hint/Hint.sol";
+import {HintVariant} from "./Hint/Hint.sol";
 
 // Maximum number of items we expect in a single Assets value.
 uint64 constant MAX_ITEMS_IN_ASSETS = 20;
@@ -12,4 +12,4 @@ uint32 constant MAX_ASSET_TRANSFER_FILTERS = 6;
 // Maximum length of a pallet name in bytes.
 uint32 constant MAX_PALLET_NAME_LEN = 48;
 // Maximum number of hints in a `SetHints` instruction, equal to the number of variants in the `Hint` enum.
-uint32 constant HINT_NUM_VARIANTS = uint32(type(HintType).max) + 1;
+uint32 constant HINT_NUM_VARIANTS = uint32(type(HintVariant).max) + 1;

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

@@ -6,7 +6,7 @@ import {AssetInstance} from "../AssetInstance/AssetInstance.sol";
 import {AssetInstanceCodec} from "../AssetInstance/AssetInstanceCodec.sol";
 
 /// @dev Discriminant for the different types of Fungibility in XCM v5.
-enum FungibilityType {
+enum FungibilityVariant {
     /// @custom:variant A fungible asset; we record a number of units, as a `uint128` in the inner item.
     Fungible,
     /// @custom:variant A non-fungible asset. We record the instance identifier in the inner item. Only one asset of each instance identifier may ever be in existence at once.
@@ -15,9 +15,9 @@ enum FungibilityType {
 
 /// @notice Classification of whether an asset is fungible or not, along with a mandatory amount or instance.
 struct Fungibility {
-    /// @custom:property The type of fungibility, determining how to interpret the payload. See `FungibilityType` enum for possible values.
-    FungibilityType fType;
-    /// @custom:property The encoded payload containing the fungibility data, whose structure depends on the `fType`.
+    /// @custom:property The type of fungibility, determining how to interpret the payload. See `FungibilityVariant` enum for possible values.
+    FungibilityVariant variant;
+    /// @custom:property The encoded payload containing the fungibility data, whose structure depends on the `variant`.
     bytes payload;
 }
 
@@ -42,7 +42,7 @@ function fungible(
 ) pure returns (Fungibility memory) {
     return
         Fungibility({
-            fType: FungibilityType.Fungible,
+            variant: FungibilityVariant.Fungible,
             payload: Compact.encode(params.amount)
         });
 }
@@ -54,7 +54,7 @@ function nonFungible(
 ) pure returns (Fungibility memory) {
     return
         Fungibility({
-            fType: FungibilityType.NonFungible,
+            variant: FungibilityVariant.NonFungible,
             payload: AssetInstanceCodec.encode(params.instance)
         });
 }

package/src/Xcm/v5/Fungibility/FungibilityCodec.sol

@@ -4,7 +4,14 @@ pragma solidity ^0.8.28;
 import {Compact} from "../../../Scale/Compact.sol";
 import {AssetInstance} from "../AssetInstance/AssetInstance.sol";
 import {AssetInstanceCodec} from "../AssetInstance/AssetInstanceCodec.sol";
-import {Fungibility, FungibilityType} from "./Fungibility.sol";
+import {
+    Fungibility,
+    FungibilityVariant,
+    FungibleParams,
+    NonFungibleParams
+} from "./Fungibility.sol";
+import {BytesUtils} from "../../../Utils/BytesUtils.sol";
+import {UnsignedUtils} from "../../../Utils/UnsignedUtils.sol";
 
 /// @title SCALE Codec for XCM v5 `Fungibility`
 /// @notice SCALE-compliant encoder/decoder for the `Fungibility` type.
@@ -12,8 +19,7 @@ import {Fungibility, FungibilityType} from "./Fungibility.sol";
 /// @dev XCM v5 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v5/index.html
 library FungibilityCodec {
     error InvalidFungibilityLength();
-    error InvalidFungibilityType(uint8 fType);
-    error InvalidFungibilityPayload();
+    error InvalidFungibilityVariant(uint8 variant);
 
     /// @notice Encodes a `Fungibility` struct into bytes.
     /// @param fungibility The `Fungibility` struct to encode.
@@ -21,7 +27,8 @@ library FungibilityCodec {
     function encode(
         Fungibility memory fungibility
     ) internal pure returns (bytes memory) {
-        return abi.encodePacked(uint8(fungibility.fType), fungibility.payload);
+        return
+            abi.encodePacked(uint8(fungibility.variant), fungibility.payload);
     }
 
     /// @notice Returns the number of bytes that a `Fungibility` struct would occupy when SCALE-encoded, starting at a given offset in the data.
@@ -35,15 +42,15 @@ library FungibilityCodec {
         if (data.length < offset + 1) {
             revert InvalidFungibilityLength();
         }
-        uint8 fType = uint8(data[offset]);
+        uint8 variant = uint8(data[offset]);
         uint256 payloadLength;
         ++offset;
-        if (fType == uint8(FungibilityType.Fungible)) {
+        if (variant == uint8(FungibilityVariant.Fungible)) {
             payloadLength = Compact.encodedSizeAt(data, offset);
-        } else if (fType == uint8(FungibilityType.NonFungible)) {
+        } else if (variant == uint8(FungibilityVariant.NonFungible)) {
             payloadLength = AssetInstanceCodec.encodedSizeAt(data, offset);
         } else {
-            revert InvalidFungibilityType(fType);
+            revert InvalidFungibilityVariant(variant);
         }
 
         if (data.length < offset + payloadLength) {
@@ -80,49 +87,46 @@ library FungibilityCodec {
         pure
         returns (Fungibility memory fungibility, uint256 bytesRead)
     {
-        if (data.length < offset + 1) {
-            revert InvalidFungibilityLength();
-        }
-        uint8 fType = uint8(data[offset]);
-        uint256 payloadLength = encodedSizeAt(data, offset) - 1; // subtract 1 byte for the fType
-        bytes memory payload = new bytes(payloadLength);
-        for (uint256 i = 0; i < payloadLength; i++) {
-            payload[i] = data[offset + 1 + i];
-        }
+        uint256 payloadLength = encodedSizeAt(data, offset) - 1; // subtract 1 byte for the variant
+        uint8 variant = uint8(data[offset]);
+        bytes memory payload = BytesUtils.copy(data, offset + 1, payloadLength);
 
         return (
-            Fungibility({fType: FungibilityType(fType), payload: payload}),
+            Fungibility({
+                variant: FungibilityVariant(variant),
+                payload: payload
+            }),
             1 + payloadLength
         );
     }
 
     /// @notice Decodes a `Fungibility` struct representing a fungible asset and extracts the amount.
-    /// @param fungibility The `Fungibility` struct to decode, which must have `fType` equal to `FungibilityType.Fungible`.
-    /// @return amount The number of units of the fungible asset, as a `uint128`.
+    /// @param fungibility The `Fungibility` struct to decode, which must have `variant` equal to `FungibilityVariant.Fungible`.
+    /// @return params A `FungibleParams` struct containing the amount of the fungible asset.
     function asFungible(
         Fungibility memory fungibility
-    ) internal pure returns (uint128 amount) {
-        if (fungibility.fType != FungibilityType.Fungible) {
-            revert InvalidFungibilityType(uint8(fungibility.fType));
-        }
+    ) internal pure returns (FungibleParams memory params) {
+        _assertVariant(fungibility, FungibilityVariant.Fungible);
         (uint256 decodedAmount, ) = Compact.decode(fungibility.payload);
-        if (decodedAmount > type(uint128).max) {
-            revert InvalidFungibilityPayload();
-        }
-        unchecked {
-            amount = uint128(decodedAmount);
-        }
+        params.amount = UnsignedUtils.toU128(decodedAmount);
     }
 
     /// @notice Decodes a `Fungibility` struct representing a non-fungible asset and extracts the instance identifier.
-    /// @param fungibility The `Fungibility` struct to decode, which must have `fType` equal to `FungibilityType.NonFungible`.
-    /// @return instance The `AssetInstance` struct identifying the specific instance of the non-fungible asset.
+    /// @param fungibility The `Fungibility` struct to decode, which must have `variant` equal to `FungibilityVariant.NonFungible`.
+    /// @return params A `NonFungibleParams` struct containing the specific non-fungible asset instance.
     function asNonFungible(
         Fungibility memory fungibility
-    ) internal pure returns (AssetInstance memory instance) {
-        if (fungibility.fType != FungibilityType.NonFungible) {
-            revert InvalidFungibilityType(uint8(fungibility.fType));
+    ) internal pure returns (NonFungibleParams memory params) {
+        _assertVariant(fungibility, FungibilityVariant.NonFungible);
+        (params.instance, ) = AssetInstanceCodec.decode(fungibility.payload);
+    }
+
+    function _assertVariant(
+        Fungibility memory fungibility,
+        FungibilityVariant expected
+    ) private pure {
+        if (fungibility.variant != expected) {
+            revert InvalidFungibilityVariant(uint8(fungibility.variant));
         }
-        (instance, ) = AssetInstanceCodec.decode(fungibility.payload);
     }
 }