solidity-scale-codec 0.3.4 → 1.0.0

package/src/Xcm/v5/AssetInstance/AssetInstanceCodec.sol

@@ -6,7 +6,17 @@ import {Bytes4} from "../../../Scale/Bytes/Bytes4.sol";
 import {Bytes8} from "../../../Scale/Bytes/Bytes8.sol";
 import {Bytes16} from "../../../Scale/Bytes/Bytes16.sol";
 import {Bytes32} from "../../../Scale/Bytes/Bytes32.sol";
-import {AssetInstance, AssetInstanceType} from "./AssetInstance.sol";
+import {
+    AssetInstance,
+    AssetInstanceVariant,
+    IndexParams,
+    Array4Params,
+    Array8Params,
+    Array16Params,
+    Array32Params
+} from "./AssetInstance.sol";
+import {BytesUtils} from "../../../Utils/BytesUtils.sol";
+import {UnsignedUtils} from "../../../Utils/UnsignedUtils.sol";
 
 /// @title SCALE Codec for XCM v5 `AssetInstance`
 /// @notice SCALE-compliant encoder/decoder for the `AssetInstance` type.
@@ -14,8 +24,7 @@ import {AssetInstance, AssetInstanceType} from "./AssetInstance.sol";
 /// @dev XCM v5 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v5/index.html
 library AssetInstanceCodec {
     error InvalidAssetInstanceLength();
-    error InvalidAssetInstanceType(uint8 iType);
-    error InvalidAssetInstancePayload();
+    error InvalidAssetInstanceVariant(uint8 variant);
 
     /// @notice Encodes an `AssetInstance` struct into bytes.
     /// @param assetInstance The `AssetInstance` struct to encode.
@@ -23,7 +32,7 @@ library AssetInstanceCodec {
     function encode(
         AssetInstance memory assetInstance
     ) internal pure returns (bytes memory) {
-        return abi.encodePacked(assetInstance.iType, assetInstance.payload);
+        return abi.encodePacked(assetInstance.variant, assetInstance.payload);
     }
 
     /// @notice Returns the total number of bytes that an `AssetInstance` would occupy when encoded, based on the type and payload.
@@ -37,22 +46,22 @@ library AssetInstanceCodec {
         if (data.length < offset + 1) {
             revert InvalidAssetInstanceLength();
         }
-        uint8 iType = uint8(data[offset]);
+        uint8 variant = uint8(data[offset]);
         uint256 payloadLength;
-        if (iType == uint8(AssetInstanceType.Index)) {
+        if (variant == uint8(AssetInstanceVariant.Index)) {
             payloadLength = Compact.encodedSizeAt(data, offset + 1);
-        } else if (iType == uint8(AssetInstanceType.Array4)) {
+        } else if (variant == uint8(AssetInstanceVariant.Array4)) {
             payloadLength = 4;
-        } else if (iType == uint8(AssetInstanceType.Array8)) {
+        } else if (variant == uint8(AssetInstanceVariant.Array8)) {
             payloadLength = 8;
-        } else if (iType == uint8(AssetInstanceType.Array16)) {
+        } else if (variant == uint8(AssetInstanceVariant.Array16)) {
             payloadLength = 16;
-        } else if (iType == uint8(AssetInstanceType.Array32)) {
+        } else if (variant == uint8(AssetInstanceVariant.Array32)) {
             payloadLength = 32;
-        } else if (iType == uint8(AssetInstanceType.Undefined)) {
+        } else if (variant == uint8(AssetInstanceVariant.Undefined)) {
             payloadLength = 0;
         } else {
-            revert InvalidAssetInstanceType(iType);
+            revert InvalidAssetInstanceVariant(variant);
         }
 
         if (data.length < offset + 1 + payloadLength) {
@@ -89,18 +98,12 @@ library AssetInstanceCodec {
         pure
         returns (AssetInstance memory assetInstance, uint256 bytesRead)
     {
-        if (data.length < offset + 1) {
-            revert InvalidAssetInstanceLength();
-        }
-        uint8 iType = uint8(data[offset]);
-        uint256 payloadLength = encodedSizeAt(data, offset) - 1; // subtract 1 byte for the iType
-        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);
 
         assetInstance = AssetInstance({
-            iType: AssetInstanceType(iType),
+            variant: AssetInstanceVariant(variant),
             payload: payload
         });
         bytesRead = 1 + payloadLength;
@@ -108,67 +111,61 @@ library AssetInstanceCodec {
 
     /// @notice Extracts the index value from an `Index` asset instance. Reverts if the asset instance is not of type `Index` or if the decoded index exceeds the maximum value for `uint128`.
     /// @param assetInstance The `AssetInstance` struct to decode, which must have type `Index`.
-    /// @return idx The index value extracted from the asset instance.
+    /// @return params A `IndexParams` struct containing the decoded index value.
     function asIndex(
         AssetInstance memory assetInstance
-    ) internal pure returns (uint128 idx) {
-        if (assetInstance.iType != AssetInstanceType.Index) {
-            revert InvalidAssetInstanceType(uint8(assetInstance.iType));
-        }
+    ) internal pure returns (IndexParams memory params) {
+        _assertVariant(assetInstance, AssetInstanceVariant.Index);
         (uint256 decodedIndex, ) = Compact.decode(assetInstance.payload);
-        if (decodedIndex > type(uint128).max) {
-            revert InvalidAssetInstancePayload();
-        }
-        unchecked {
-            idx = uint128(decodedIndex);
-        }
+        params.index = UnsignedUtils.toU128(decodedIndex);
     }
 
     /// @notice Extracts the 4-byte data from an `Array4` asset instance. Reverts if the asset instance is not of type `Array4`.
     /// @param assetInstance The `AssetInstance` struct to decode, which must have type `Array4`.
-    /// @return data The 4-byte data extracted from the asset instance.
+    /// @return params A `Array4Params` struct containing the decoded 4-byte data.
     function asArray4(
         AssetInstance memory assetInstance
-    ) internal pure returns (bytes4 data) {
-        if (assetInstance.iType != AssetInstanceType.Array4) {
-            revert InvalidAssetInstanceType(uint8(assetInstance.iType));
-        }
-        return Bytes4.decode(assetInstance.payload);
+    ) internal pure returns (Array4Params memory params) {
+        _assertVariant(assetInstance, AssetInstanceVariant.Array4);
+        params.data = Bytes4.decode(assetInstance.payload);
     }
 
     /// @notice Extracts the 8-byte data from an `Array8` asset instance. Reverts if the asset instance is not of type `Array8`.
     /// @param assetInstance The `AssetInstance` struct to decode, which must have type `Array8`.
-    /// @return data The 8-byte data extracted from the asset instance.
+    /// @return params A `Array8Params` struct containing the decoded 8-byte data.
     function asArray8(
         AssetInstance memory assetInstance
-    ) internal pure returns (bytes8 data) {
-        if (assetInstance.iType != AssetInstanceType.Array8) {
-            revert InvalidAssetInstanceType(uint8(assetInstance.iType));
-        }
-        return Bytes8.decode(assetInstance.payload);
+    ) internal pure returns (Array8Params memory params) {
+        _assertVariant(assetInstance, AssetInstanceVariant.Array8);
+        params.data = Bytes8.decode(assetInstance.payload);
     }
 
     /// @notice Extracts the 16-byte data from an `Array16` asset instance. Reverts if the asset instance is not of type `Array16`.
     /// @param assetInstance The `AssetInstance` struct to decode, which must have type `Array16`.
-    /// @return data The 16-byte data extracted from the asset instance.
+    /// @return params A `Array16Params` struct containing the decoded 16-byte data.
     function asArray16(
         AssetInstance memory assetInstance
-    ) internal pure returns (bytes16 data) {
-        if (assetInstance.iType != AssetInstanceType.Array16) {
-            revert InvalidAssetInstanceType(uint8(assetInstance.iType));
-        }
-        return Bytes16.decode(assetInstance.payload);
+    ) internal pure returns (Array16Params memory params) {
+        _assertVariant(assetInstance, AssetInstanceVariant.Array16);
+        params.data = Bytes16.decode(assetInstance.payload);
     }
 
     /// @notice Extracts the 32-byte data from an `Array32` asset instance. Reverts if the asset instance is not of type `Array32`.
     /// @param assetInstance The `AssetInstance` struct to decode, which must have type `Array32`.
-    /// @return data The 32-byte data extracted from the asset instance.
+    /// @return params A `Array32Params` struct containing the decoded 32-byte data.
     function asArray32(
         AssetInstance memory assetInstance
-    ) internal pure returns (bytes32 data) {
-        if (assetInstance.iType != AssetInstanceType.Array32) {
-            revert InvalidAssetInstanceType(uint8(assetInstance.iType));
+    ) internal pure returns (Array32Params memory params) {
+        _assertVariant(assetInstance, AssetInstanceVariant.Array32);
+        params.data = Bytes32.decode(assetInstance.payload);
+    }
+
+    function _assertVariant(
+        AssetInstance memory assetInstance,
+        AssetInstanceVariant expected
+    ) private pure {
+        if (assetInstance.variant != expected) {
+            revert InvalidAssetInstanceVariant(uint8(assetInstance.variant));
         }
-        return Bytes32.decode(assetInstance.payload);
     }
 }

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

@@ -5,7 +5,7 @@ import {AssetFilter} from "../AssetFilter/AssetFilter.sol";
 import {AssetFilterCodec} from "../AssetFilter/AssetFilterCodec.sol";
 
 /// @notice Discriminant for the `AssetTransferFilter` enum.
-enum AssetTransferFilterType {
+enum AssetTransferFilterVariant {
     /// @custom:variant Teleport assets matching `AssetFilter` to a specific destination.
     Teleport,
     /// @custom:variant Reserve-transfer assets matching `AssetFilter` to a specific destination, using the local chain as reserve.
@@ -16,8 +16,8 @@ enum AssetTransferFilterType {
 
 /// @notice Matches assets based on inner `AssetFilter` and tags them for a specific type of asset transfer.
 struct AssetTransferFilter {
-    /// @custom:property The type of asset transfer. See `AssetTransferFilterType` enum for possible values.
-    AssetTransferFilterType atfType;
+    /// @custom:property The type of asset transfer. See `AssetTransferFilterVariant` enum for possible values.
+    AssetTransferFilterVariant variant;
     /// @custom:property The SCALE-encoded `AssetFilter` payload.
     bytes payload;
 }
@@ -25,19 +25,19 @@ struct AssetTransferFilter {
 /// @notice Parameters for the `Teleport` variant.
 struct TeleportParams {
     /// @custom:property Asset filter used for teleport transfer.
-    AssetFilter filter;
+    AssetFilter assetFilter;
 }
 
 /// @notice Parameters for the `ReserveDeposit` variant.
 struct ReserveDepositParams {
     /// @custom:property Asset filter used for reserve-deposit transfer.
-    AssetFilter filter;
+    AssetFilter assetFilter;
 }
 
 /// @notice Parameters for the `ReserveWithdraw` variant.
 struct ReserveWithdrawParams {
     /// @custom:property Asset filter used for reserve-withdraw transfer.
-    AssetFilter filter;
+    AssetFilter assetFilter;
 }
 
 // ============ Factory Functions ============
@@ -50,8 +50,8 @@ function teleport(
 ) pure returns (AssetTransferFilter memory) {
     return
         AssetTransferFilter({
-            atfType: AssetTransferFilterType.Teleport,
-            payload: AssetFilterCodec.encode(params.filter)
+            variant: AssetTransferFilterVariant.Teleport,
+            payload: AssetFilterCodec.encode(params.assetFilter)
         });
 }
 
@@ -63,8 +63,8 @@ function reserveDeposit(
 ) pure returns (AssetTransferFilter memory) {
     return
         AssetTransferFilter({
-            atfType: AssetTransferFilterType.ReserveDeposit,
-            payload: AssetFilterCodec.encode(params.filter)
+            variant: AssetTransferFilterVariant.ReserveDeposit,
+            payload: AssetFilterCodec.encode(params.assetFilter)
         });
 }
 
@@ -76,7 +76,7 @@ function reserveWithdraw(
 ) pure returns (AssetTransferFilter memory) {
     return
         AssetTransferFilter({
-            atfType: AssetTransferFilterType.ReserveWithdraw,
-            payload: AssetFilterCodec.encode(params.filter)
+            variant: AssetTransferFilterVariant.ReserveWithdraw,
+            payload: AssetFilterCodec.encode(params.assetFilter)
         });
 }

package/src/Xcm/v5/AssetTransferFilter/AssetTransferFilterCodec.sol

@@ -5,8 +5,12 @@ import {AssetFilter} from "../AssetFilter/AssetFilter.sol";
 import {AssetFilterCodec} from "../AssetFilter/AssetFilterCodec.sol";
 import {
     AssetTransferFilter,
-    AssetTransferFilterType
+    AssetTransferFilterVariant,
+    TeleportParams,
+    ReserveDepositParams,
+    ReserveWithdrawParams
 } from "./AssetTransferFilter.sol";
+import {BytesUtils} from "../../../Utils/BytesUtils.sol";
 
 /// @title SCALE Codec for XCM v5 `AssetTransferFilter`
 /// @notice SCALE-compliant encoder/decoder for the `AssetTransferFilter` type.
@@ -14,7 +18,7 @@ import {
 /// @dev XCM v5 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v5/enum.AssetTransferFilter.html
 library AssetTransferFilterCodec {
     error InvalidAssetTransferFilterLength();
-    error InvalidAssetTransferFilterType(uint8 atfType);
+    error InvalidAssetTransferFilterVariant(uint8 variant);
 
     /// @notice Encodes an `AssetTransferFilter` struct into SCALE bytes.
     /// @param atf The `AssetTransferFilter` struct to encode.
@@ -22,7 +26,7 @@ library AssetTransferFilterCodec {
     function encode(
         AssetTransferFilter memory atf
     ) internal pure returns (bytes memory) {
-        return abi.encodePacked(uint8(atf.atfType), atf.payload);
+        return abi.encodePacked(uint8(atf.variant), atf.payload);
     }
 
     /// @notice Returns the number of bytes that an `AssetTransferFilter` would occupy when SCALE-encoded.
@@ -34,9 +38,9 @@ library AssetTransferFilterCodec {
         uint256 offset
     ) internal pure returns (uint256) {
         if (data.length < offset + 1) revert InvalidAssetTransferFilterLength();
-        uint8 atfType = uint8(data[offset]);
-        if (atfType > uint8(AssetTransferFilterType.ReserveWithdraw))
-            revert InvalidAssetTransferFilterType(atfType);
+        uint8 variant = uint8(data[offset]);
+        if (variant > uint8(AssetTransferFilterVariant.ReserveWithdraw))
+            revert InvalidAssetTransferFilterVariant(variant);
         return 1 + AssetFilterCodec.encodedSizeAt(data, offset + 1);
     }
 
@@ -67,29 +71,53 @@ library AssetTransferFilterCodec {
         pure
         returns (AssetTransferFilter memory atf, uint256 bytesRead)
     {
-        if (data.length < offset + 1) revert InvalidAssetTransferFilterLength();
-        uint8 atfType = uint8(data[offset]);
-        if (atfType > uint8(AssetTransferFilterType.ReserveWithdraw))
-            revert InvalidAssetTransferFilterType(atfType);
         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];
-        }
+        bytes memory payload = BytesUtils.copy(data, offset + 1, payloadLength);
         atf = AssetTransferFilter({
-            atfType: AssetTransferFilterType(atfType),
+            variant: AssetTransferFilterVariant(variant),
             payload: payload
         });
         bytesRead = size;
     }
 
-    /// @notice Extracts the inner `AssetFilter` from an `AssetTransferFilter`.
+    /// @notice Extracts the inner `AssetFilter` from an `AssetTransferFilter` with `Teleport` variant
     /// @param atf The `AssetTransferFilter` struct to decode.
-    /// @return The inner `AssetFilter`.
-    function asInner(
+    /// @return params A `TeleportParams` struct containing the inner `AssetFilter`.
+    function asTeleport(
         AssetTransferFilter memory atf
-    ) internal pure returns (AssetFilter memory) {
-        return AssetFilterCodec.decode(atf.payload);
+    ) internal pure returns (TeleportParams memory params) {
+        _assertVariant(atf, AssetTransferFilterVariant.Teleport);
+        (params.assetFilter, ) = AssetFilterCodec.decode(atf.payload);
+    }
+
+    /// @notice Extracts the inner `AssetFilter` from an `AssetTransferFilter` with `ReserveDeposit` variant
+    /// @param atf The `AssetTransferFilter` struct to decode.
+    /// @return params A `ReserveDepositParams` struct containing the inner `AssetFilter`.
+    function asReserveDeposit(
+        AssetTransferFilter memory atf
+    ) internal pure returns (ReserveDepositParams memory params) {
+        _assertVariant(atf, AssetTransferFilterVariant.ReserveDeposit);
+        (params.assetFilter, ) = AssetFilterCodec.decode(atf.payload);
+    }
+
+    /// @notice Extracts the inner `AssetFilter` from an `AssetTransferFilter` with `ReserveWithdraw` variant
+    /// @param atf The `AssetTransferFilter` struct to decode.
+    /// @return params A `ReserveWithdrawParams` struct containing the inner `AssetFilter`.
+    function asReserveWithdraw(
+        AssetTransferFilter memory atf
+    ) internal pure returns (ReserveWithdrawParams memory params) {
+        _assertVariant(atf, AssetTransferFilterVariant.ReserveWithdraw);
+        (params.assetFilter, ) = AssetFilterCodec.decode(atf.payload);
+    }
+
+    function _assertVariant(
+        AssetTransferFilter memory atf,
+        AssetTransferFilterVariant expected
+    ) internal pure {
+        if (atf.variant != expected) {
+            revert InvalidAssetTransferFilterVariant(uint8(atf.variant));
+        }
     }
 }

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

@@ -12,3 +12,19 @@ struct Assets {
     /// @custom:property The items of the array.
     Asset[] items;
 }
+
+/// @notice Creates an `Assets` wrapper from a single `Asset`.
+/// @param asset The asset to include.
+/// @return An `Assets` struct containing one item.
+function fromAsset(Asset memory asset) pure returns (Assets memory) {
+    Asset[] memory items = new Asset[](1);
+    items[0] = asset;
+    return Assets({items: items});
+}
+
+/// @notice Creates an `Assets` wrapper from an asset array.
+/// @param assets The assets to include.
+/// @return An `Assets` struct containing `assets`.
+function fromAssets(Asset[] memory assets) pure returns (Assets memory) {
+    return Assets({items: assets});
+}

package/src/Xcm/v5/Assets/AssetsCodec.sol

@@ -41,6 +41,9 @@ library AssetsCodec {
             revert InvalidAssetsLength();
         }
         (uint256 length, uint256 bytesRead) = Compact.decodeAt(data, offset);
+        if (length > MAX_ITEMS_IN_ASSETS) {
+            revert InvalidAssetsPayload();
+        }
         uint256 currentOffset = offset + bytesRead;
         for (uint256 i = 0; i < length; i++) {
             uint256 assetSize = AssetCodec.encodedSizeAt(data, currentOffset);
@@ -68,9 +71,6 @@ library AssetsCodec {
         bytes memory data,
         uint256 offset
     ) internal pure returns (Assets memory assets, uint256 bytesRead) {
-        if (data.length < offset + 1) {
-            revert InvalidAssetsLength();
-        }
         (uint256 length, uint256 compactBytesRead) = Compact.decodeAt(
             data,
             offset

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

@@ -5,7 +5,7 @@ import {Bytes4} from "../../../Scale/Bytes.sol";
 import {Compact} from "../../../Scale/Compact.sol";
 
 /// @dev Discriminant for the different types of BodyIds in XCM v5. Each variant corresponds to a specific structure of the payload.
-enum BodyIdType {
+enum BodyIdVariant {
     /// @custom:variant The only body in its context.
     Unit,
     /// @custom:variant A named body.
@@ -31,7 +31,7 @@ enum BodyIdType {
 /// @notice An identifier of a pluralistic body.
 struct BodyId {
     /// @custom:property The type of BodyId, which determines how to interpret the payload
-    BodyIdType bodyIdType;
+    BodyIdVariant variant;
     /// @custom:property For Moniker and Index types, this will hold the relevant data
     bytes payload;
 }
@@ -45,77 +45,77 @@ struct MonikerParams {
 /// @notice Parameters for the `Index` variant.
 struct IndexParams {
     /// @custom:property The index of the body.
-    uint32 idx;
+    uint32 index;
 }
 
 // ============ Factory Functions ============
 
 /// @notice Creates a `BodyId` representing a `Unit` body.
-/// @return A `BodyId` with `bodyIdType` set to `Unit` and an empty payload.
+/// @return A `BodyId` with `variant` set to `Unit` and an empty payload.
 function unit() pure returns (BodyId memory) {
-    return BodyId({bodyIdType: BodyIdType.Unit, payload: ""});
+    return BodyId({variant: BodyIdVariant.Unit, payload: ""});
 }
 
 /// @notice Creates a `BodyId` representing a `Moniker` body with the given 4-byte name.
 /// @param params Parameters for the moniker variant.
-/// @return A `BodyId` with `bodyIdType` set to `Moniker` and the provided name encoded in the payload.
+/// @return A `BodyId` with `variant` set to `Moniker` and the provided name encoded in the payload.
 function moniker(MonikerParams memory params) pure returns (BodyId memory) {
     return
         BodyId({
-            bodyIdType: BodyIdType.Moniker,
+            variant: BodyIdVariant.Moniker,
             payload: Bytes4.encode(params.name)
         });
 }
 
 /// @notice Creates a `BodyId` representing an `Index` body with the given index.
 /// @param params Parameters for the index variant.
-/// @return A `BodyId` with `bodyIdType` set to `Index` and the provided index encoded in the payload.
+/// @return A `BodyId` with `variant` set to `Index` and the provided index encoded in the payload.
 function index(IndexParams memory params) pure returns (BodyId memory) {
     return
         BodyId({
-            bodyIdType: BodyIdType.Index,
-            payload: Compact.encode(params.idx)
+            variant: BodyIdVariant.Index,
+            payload: Compact.encode(params.index)
         });
 }
 
 /// @notice Creates a `BodyId` representing an `Executive` body.
-/// @return A `BodyId` with `bodyIdType` set to `Executive` and an empty payload.
+/// @return A `BodyId` with `variant` set to `Executive` and an empty payload.
 function executive() pure returns (BodyId memory) {
-    return BodyId({bodyIdType: BodyIdType.Executive, payload: ""});
+    return BodyId({variant: BodyIdVariant.Executive, payload: ""});
 }
 
 /// @notice Creates a `BodyId` representing a `Technical` body.
-/// @return A `BodyId` with `bodyIdType` set to `Technical` and an empty payload.
+/// @return A `BodyId` with `variant` set to `Technical` and an empty payload.
 function technical() pure returns (BodyId memory) {
-    return BodyId({bodyIdType: BodyIdType.Technical, payload: ""});
+    return BodyId({variant: BodyIdVariant.Technical, payload: ""});
 }
 
 /// @notice Creates a `BodyId` representing a `Legislative` body.
-/// @return A `BodyId` with `bodyIdType` set to `Legislative` and an empty payload.
+/// @return A `BodyId` with `variant` set to `Legislative` and an empty payload.
 function legislative() pure returns (BodyId memory) {
-    return BodyId({bodyIdType: BodyIdType.Legislative, payload: ""});
+    return BodyId({variant: BodyIdVariant.Legislative, payload: ""});
 }
 
 /// @notice Creates a `BodyId` representing a `Judicial` body.
-/// @return A `BodyId` with `bodyIdType` set to `Judicial` and an empty payload.
+/// @return A `BodyId` with `variant` set to `Judicial` and an empty payload.
 function judicial() pure returns (BodyId memory) {
-    return BodyId({bodyIdType: BodyIdType.Judicial, payload: ""});
+    return BodyId({variant: BodyIdVariant.Judicial, payload: ""});
 }
 
 /// @notice Creates a `BodyId` representing a `Defense` body.
-/// @return A `BodyId` with `bodyIdType` set to `Defense` and an empty payload.
+/// @return A `BodyId` with `variant` set to `Defense` and an empty payload.
 function defense() pure returns (BodyId memory) {
-    return BodyId({bodyIdType: BodyIdType.Defense, payload: ""});
+    return BodyId({variant: BodyIdVariant.Defense, payload: ""});
 }
 
 /// @notice Creates a `BodyId` representing an `Administration` body.
-/// @return A `BodyId` with `bodyIdType` set to `Administration` and an empty payload.
+/// @return A `BodyId` with `variant` set to `Administration` and an empty payload.
 function administration() pure returns (BodyId memory) {
-    return BodyId({bodyIdType: BodyIdType.Administration, payload: ""});
+    return BodyId({variant: BodyIdVariant.Administration, payload: ""});
 }
 
 /// @notice Creates a `BodyId` representing a `Treasury` body.
-/// @return A `BodyId` with `bodyIdType` set to `Treasury` and an empty payload.
+/// @return A `BodyId` with `variant` set to `Treasury` and an empty payload.
 function treasury() pure returns (BodyId memory) {
-    return BodyId({bodyIdType: BodyIdType.Treasury, payload: ""});
+    return BodyId({variant: BodyIdVariant.Treasury, payload: ""});
 }