solidity-scale-codec 0.1.3 → 0.3.0

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

@@ -0,0 +1,174 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Compact} from "../../../Scale/Compact.sol";
+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";
+
+/// @title SCALE Codec for XCM v5 `AssetInstance`
+/// @notice SCALE-compliant encoder/decoder for the `AssetInstance` 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 AssetInstanceCodec {
+    error InvalidAssetInstanceLength();
+    error InvalidAssetInstanceType(uint8 iType);
+    error InvalidAssetInstancePayload();
+
+    /// @notice Encodes an `AssetInstance` struct into bytes.
+    /// @param assetInstance The `AssetInstance` struct to encode.
+    /// @return SCALE-encoded byte sequence representing the `AssetInstance`.
+    function encode(
+        AssetInstance memory assetInstance
+    ) internal pure returns (bytes memory) {
+        return abi.encodePacked(assetInstance.iType, assetInstance.payload);
+    }
+
+    /// @notice Returns the total number of bytes that an `AssetInstance` would occupy when encoded, based on the type and payload.
+    /// @param data The byte sequence containing the encoded `AssetInstance`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size.
+    /// @return The total number of bytes that the `AssetInstance` occupies in its encoded form, including the type byte and payload.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (data.length < offset + 1) {
+            revert InvalidAssetInstanceLength();
+        }
+        uint8 iType = uint8(data[offset]);
+        uint256 payloadLength;
+        if (iType == uint8(AssetInstanceType.Index)) {
+            payloadLength = Compact.encodedSizeAt(data, offset + 1);
+        } else if (iType == uint8(AssetInstanceType.Array4)) {
+            payloadLength = 4;
+        } else if (iType == uint8(AssetInstanceType.Array8)) {
+            payloadLength = 8;
+        } else if (iType == uint8(AssetInstanceType.Array16)) {
+            payloadLength = 16;
+        } else if (iType == uint8(AssetInstanceType.Array32)) {
+            payloadLength = 32;
+        } else if (iType == uint8(AssetInstanceType.Undefined)) {
+            payloadLength = 0;
+        } else {
+            revert InvalidAssetInstanceType(iType);
+        }
+
+        if (data.length < offset + 1 + payloadLength) {
+            revert InvalidAssetInstanceLength();
+        }
+
+        return 1 + payloadLength;
+    }
+
+    /// @notice Decodes an `AssetInstance` struct from bytes starting at the beginning of the data.
+    /// @param data The byte sequence containing the encoded `AssetInstance`.
+    /// @return assetInstance The decoded `AssetInstance` struct.
+    /// @return bytesRead The total number of bytes read from `data` to decode the `AssetInstance`.
+    function decode(
+        bytes memory data
+    )
+        internal
+        pure
+        returns (AssetInstance memory assetInstance, uint256 bytesRead)
+    {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `AssetInstance` struct from bytes starting at a given offset.
+    /// @param data The byte sequence containing the encoded `AssetInstance`.
+    /// @param offset The starting index in `data` from which to decode the `AssetInstance`.
+    /// @return assetInstance The decoded `AssetInstance` struct.
+    /// @return bytesRead The total number of bytes read from `data` to decode the `AssetInstance`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    )
+        internal
+        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];
+        }
+
+        assetInstance = AssetInstance({
+            iType: AssetInstanceType(iType),
+            payload: payload
+        });
+        bytesRead = 1 + payloadLength;
+    }
+
+    /// @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.
+    function asIndex(
+        AssetInstance memory assetInstance
+    ) internal pure returns (uint128 idx) {
+        if (assetInstance.iType != AssetInstanceType.Index) {
+            revert InvalidAssetInstanceType(uint8(assetInstance.iType));
+        }
+        (uint256 decodedIndex, ) = Compact.decode(assetInstance.payload);
+        if (decodedIndex > type(uint128).max) {
+            revert InvalidAssetInstancePayload();
+        }
+        unchecked {
+            idx = uint128(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.
+    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);
+    }
+
+    /// @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.
+    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);
+    }
+
+    /// @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.
+    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);
+    }
+
+    /// @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.
+    function asArray32(
+        AssetInstance memory assetInstance
+    ) internal pure returns (bytes32 data) {
+        if (assetInstance.iType != AssetInstanceType.Array32) {
+            revert InvalidAssetInstanceType(uint8(assetInstance.iType));
+        }
+        return Bytes32.decode(assetInstance.payload);
+    }
+}

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

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {AssetFilter} from "../AssetFilter/AssetFilter.sol";
+import {AssetFilterCodec} from "../AssetFilter/AssetFilterCodec.sol";
+
+/// @notice Discriminant for the `AssetTransferFilter` enum.
+enum AssetTransferFilterType {
+    /// @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.
+    ReserveDeposit,
+    /// @custom:variant Reserve-transfer assets matching `AssetFilter` to a specific destination, using the destination as reserve.
+    ReserveWithdraw
+}
+
+/// @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 SCALE-encoded `AssetFilter` payload.
+    bytes payload;
+}
+
+/// @notice Parameters for the `Teleport` variant.
+struct TeleportParams {
+    /// @custom:property Asset filter used for teleport transfer.
+    AssetFilter filter;
+}
+
+/// @notice Parameters for the `ReserveDeposit` variant.
+struct ReserveDepositParams {
+    /// @custom:property Asset filter used for reserve-deposit transfer.
+    AssetFilter filter;
+}
+
+/// @notice Parameters for the `ReserveWithdraw` variant.
+struct ReserveWithdrawParams {
+    /// @custom:property Asset filter used for reserve-withdraw transfer.
+    AssetFilter filter;
+}
+
+// ============ Factory Functions ============
+
+/// @notice Creates a `Teleport` asset transfer filter.
+/// @param params Parameters for the teleport variant.
+/// @return An `AssetTransferFilter` struct representing the teleport filter.
+function teleport(
+    TeleportParams memory params
+) pure returns (AssetTransferFilter memory) {
+    return
+        AssetTransferFilter({
+            atfType: AssetTransferFilterType.Teleport,
+            payload: AssetFilterCodec.encode(params.filter)
+        });
+}
+
+/// @notice Creates a `ReserveDeposit` asset transfer filter.
+/// @param params Parameters for the reserve-deposit variant.
+/// @return An `AssetTransferFilter` struct representing the reserve deposit filter.
+function reserveDeposit(
+    ReserveDepositParams memory params
+) pure returns (AssetTransferFilter memory) {
+    return
+        AssetTransferFilter({
+            atfType: AssetTransferFilterType.ReserveDeposit,
+            payload: AssetFilterCodec.encode(params.filter)
+        });
+}
+
+/// @notice Creates a `ReserveWithdraw` asset transfer filter.
+/// @param params Parameters for the reserve-withdraw variant.
+/// @return An `AssetTransferFilter` struct representing the reserve withdraw filter.
+function reserveWithdraw(
+    ReserveWithdrawParams memory params
+) pure returns (AssetTransferFilter memory) {
+    return
+        AssetTransferFilter({
+            atfType: AssetTransferFilterType.ReserveWithdraw,
+            payload: AssetFilterCodec.encode(params.filter)
+        });
+}

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

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {AssetFilter} from "../AssetFilter/AssetFilter.sol";
+import {AssetFilterCodec} from "../AssetFilter/AssetFilterCodec.sol";
+import {
+    AssetTransferFilter,
+    AssetTransferFilterType
+} from "./AssetTransferFilter.sol";
+
+/// @title SCALE Codec for XCM v5 `AssetTransferFilter`
+/// @notice SCALE-compliant encoder/decoder for the `AssetTransferFilter` 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/enum.AssetTransferFilter.html
+library AssetTransferFilterCodec {
+    error InvalidAssetTransferFilterLength();
+    error InvalidAssetTransferFilterType(uint8 atfType);
+
+    /// @notice Encodes an `AssetTransferFilter` struct into SCALE bytes.
+    /// @param atf The `AssetTransferFilter` struct to encode.
+    /// @return SCALE-encoded bytes representing the `AssetTransferFilter`.
+    function encode(
+        AssetTransferFilter memory atf
+    ) internal pure returns (bytes memory) {
+        return abi.encodePacked(uint8(atf.atfType), atf.payload);
+    }
+
+    /// @notice Returns the number of bytes that an `AssetTransferFilter` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `AssetTransferFilter`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size.
+    /// @return The number of bytes occupied by the encoded `AssetTransferFilter`.
+    function encodedSizeAt(
+        bytes memory data,
+        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);
+        return 1 + AssetFilterCodec.encodedSizeAt(data, offset + 1);
+    }
+
+    /// @notice Decodes an `AssetTransferFilter` from SCALE bytes starting at the beginning.
+    /// @param data The byte sequence containing the encoded `AssetTransferFilter`.
+    /// @return atf The decoded `AssetTransferFilter` struct.
+    /// @return bytesRead The number of bytes read.
+    function decode(
+        bytes memory data
+    )
+        internal
+        pure
+        returns (AssetTransferFilter memory atf, uint256 bytesRead)
+    {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `AssetTransferFilter` from SCALE bytes starting at a given offset.
+    /// @param data The byte sequence containing the encoded `AssetTransferFilter`.
+    /// @param offset The starting index in `data` from which to decode.
+    /// @return atf The decoded `AssetTransferFilter` struct.
+    /// @return bytesRead The number of bytes read.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    )
+        internal
+        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);
+        uint256 payloadLength = size - 1;
+        bytes memory payload = new bytes(payloadLength);
+        for (uint256 i = 0; i < payloadLength; ++i) {
+            payload[i] = data[offset + 1 + i];
+        }
+        atf = AssetTransferFilter({
+            atfType: AssetTransferFilterType(atfType),
+            payload: payload
+        });
+        bytesRead = size;
+    }
+
+    /// @notice Extracts the inner `AssetFilter` from an `AssetTransferFilter`.
+    /// @param atf The `AssetTransferFilter` struct to decode.
+    /// @return The inner `AssetFilter`.
+    function asInner(
+        AssetTransferFilter memory atf
+    ) internal pure returns (AssetFilter memory) {
+        return AssetFilterCodec.decode(atf.payload);
+    }
+}

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

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Asset} from "../Asset/Asset.sol";
+
+/// @notice An array of Assets.
+/// @dev There are a number of invariants which the construction and mutation functions must ensure are maintained:
+/// - It may contain no items of duplicate asset class.
+/// - All items must be ordered.
+/// - The number of items should grow no larger than `MAX_ITEMS_IN_ASSETS`.
+struct Assets {
+    /// @custom:property The items of the array.
+    Asset[] items;
+}

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

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Asset} from "../Asset/Asset.sol";
+import {AssetCodec} from "../Asset/AssetCodec.sol";
+import {Compact} from "../../../Scale/Compact.sol";
+import {MAX_ITEMS_IN_ASSETS} from "../Constants.sol";
+import {Assets} from "./Assets.sol";
+
+/// @title SCALE Codec for XCM v5 `Assets`
+/// @notice SCALE-compliant encoder/decoder for the `Assets` 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 AssetsCodec {
+    error InvalidAssetsLength();
+    error InvalidAssetsPayload();
+
+    /// @notice Encodes an `Assets` struct into bytes.
+    /// @param assets The `Assets` struct to encode. Assumes that the `items` array is properly constructed according to the invariants specified in the `Assets` struct definition.
+    /// @return SCALE-encoded byte sequence representing the `Assets`.
+    function encode(Assets memory assets) internal pure returns (bytes memory) {
+        bytes memory encoded = Compact.encode(assets.items.length);
+        for (uint256 i = 0; i < assets.items.length; i++) {
+            encoded = abi.encodePacked(
+                encoded,
+                AssetCodec.encode(assets.items[i])
+            );
+        }
+        return encoded;
+    }
+
+    /// @notice Returns the number of bytes that an `Assets` struct would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `Assets`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `Assets`.
+    /// @return The number of bytes that the `Assets` struct would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (data.length < offset + 1) {
+            revert InvalidAssetsLength();
+        }
+        (uint256 length, uint256 bytesRead) = Compact.decodeAt(data, offset);
+        uint256 currentOffset = offset + bytesRead;
+        for (uint256 i = 0; i < length; i++) {
+            uint256 assetSize = AssetCodec.encodedSizeAt(data, currentOffset);
+            currentOffset += assetSize;
+        }
+        return currentOffset - offset;
+    }
+
+    /// @notice Decodes an `Assets` struct from bytes starting at the beginning of the data.
+    /// @param data The byte sequence containing the encoded `Assets`.
+    /// @return assets The decoded `Assets` struct.
+    /// @return bytesRead The total number of bytes read from `data` to decode the `Assets`.
+    function decode(
+        bytes memory data
+    ) internal pure returns (Assets memory assets, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `Assets` struct from bytes starting at a given offset.
+    /// @param data The byte sequence containing the encoded `Assets`.
+    /// @param offset The starting index in `data` from which to decode the `Assets`.
+    /// @return assets The decoded `Assets` struct.
+    /// @return bytesRead The total number of bytes read from `data` to decode the `Assets`.
+    function decodeAt(
+        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
+        );
+        if (length > MAX_ITEMS_IN_ASSETS) {
+            revert InvalidAssetsPayload();
+        }
+        Asset[] memory items = new Asset[](length);
+        uint256 currentOffset = offset + compactBytesRead;
+        for (uint256 i = 0; i < length; i++) {
+            (Asset memory asset, uint256 assetBytesRead) = AssetCodec.decodeAt(
+                data,
+                currentOffset
+            );
+            items[i] = asset;
+            currentOffset += assetBytesRead;
+        }
+        assets = Assets({items: items});
+        bytesRead = 1 + currentOffset - offset - 1;
+    }
+}

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

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+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 {
+    /// @custom:variant The only body in its context.
+    Unit,
+    /// @custom:variant A named body.
+    Moniker,
+    /// @custom:variant An indexed body.
+    Index,
+    /// @custom:variant The unambiguous executive body (for Polkadot, this would be the Polkadot council).
+    Executive,
+    /// @custom:variant The unambiguous technical body (for Polkadot, this would be the Technical Committee).
+    Technical,
+    /// @custom:variant The unambiguous legislative body (for Polkadot, this could be considered the opinion of a majority of lock-voters).
+    Legislative,
+    /// @custom:variant The unambiguous judicial body (this doesn’t exist on Polkadot, but if it were to get a “grand oracle”, it may be considered as that).
+    Judicial,
+    /// @custom:variant The unambiguous defense body (for Polkadot, an opinion on the topic given via a public referendum on the `staking_admin` track).
+    Defense,
+    /// @custom:variant The unambiguous administration body (for Polkadot, an opinion on the topic given via a public referendum on the `general_admin` track).
+    Administration,
+    /// @custom:variant The unambiguous treasury body (for Polkadot, an opinion on the topic given via a public referendum on the `treasurer` track).
+    Treasury
+}
+
+/// @notice An identifier of a pluralistic body.
+struct BodyId {
+    /// @custom:property The type of BodyId, which determines how to interpret the payload
+    BodyIdType bodyIdType;
+    /// @custom:property For Moniker and Index types, this will hold the relevant data
+    bytes payload;
+}
+
+/// @notice Parameters for the `Moniker` variant.
+struct MonikerParams {
+    /// @custom:property The 4-byte name of the moniker body.
+    bytes4 name;
+}
+
+/// @notice Parameters for the `Index` variant.
+struct IndexParams {
+    /// @custom:property The index of the body.
+    uint32 idx;
+}
+
+// ============ Factory Functions ============
+
+/// @notice Creates a `BodyId` representing a `Unit` body.
+/// @return A `BodyId` with `bodyIdType` set to `Unit` and an empty payload.
+function unit() pure returns (BodyId memory) {
+    return BodyId({bodyIdType: BodyIdType.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.
+function moniker(MonikerParams memory params) pure returns (BodyId memory) {
+    return
+        BodyId({
+            bodyIdType: BodyIdType.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.
+function index(IndexParams memory params) pure returns (BodyId memory) {
+    return
+        BodyId({
+            bodyIdType: BodyIdType.Index,
+            payload: Compact.encode(params.idx)
+        });
+}
+
+/// @notice Creates a `BodyId` representing an `Executive` body.
+/// @return A `BodyId` with `bodyIdType` set to `Executive` and an empty payload.
+function executive() pure returns (BodyId memory) {
+    return BodyId({bodyIdType: BodyIdType.Executive, payload: ""});
+}
+
+/// @notice Creates a `BodyId` representing a `Technical` body.
+/// @return A `BodyId` with `bodyIdType` set to `Technical` and an empty payload.
+function technical() pure returns (BodyId memory) {
+    return BodyId({bodyIdType: BodyIdType.Technical, payload: ""});
+}
+
+/// @notice Creates a `BodyId` representing a `Legislative` body.
+/// @return A `BodyId` with `bodyIdType` set to `Legislative` and an empty payload.
+function legislative() pure returns (BodyId memory) {
+    return BodyId({bodyIdType: BodyIdType.Legislative, payload: ""});
+}
+
+/// @notice Creates a `BodyId` representing a `Judicial` body.
+/// @return A `BodyId` with `bodyIdType` set to `Judicial` and an empty payload.
+function judicial() pure returns (BodyId memory) {
+    return BodyId({bodyIdType: BodyIdType.Judicial, payload: ""});
+}
+
+/// @notice Creates a `BodyId` representing a `Defense` body.
+/// @return A `BodyId` with `bodyIdType` set to `Defense` and an empty payload.
+function defense() pure returns (BodyId memory) {
+    return BodyId({bodyIdType: BodyIdType.Defense, payload: ""});
+}
+
+/// @notice Creates a `BodyId` representing an `Administration` body.
+/// @return A `BodyId` with `bodyIdType` set to `Administration` and an empty payload.
+function administration() pure returns (BodyId memory) {
+    return BodyId({bodyIdType: BodyIdType.Administration, payload: ""});
+}
+
+/// @notice Creates a `BodyId` representing a `Treasury` body.
+/// @return A `BodyId` with `bodyIdType` set to `Treasury` and an empty payload.
+function treasury() pure returns (BodyId memory) {
+    return BodyId({bodyIdType: BodyIdType.Treasury, payload: ""});
+}