solidity-scale-codec 0.3.4 → 1.0.1

package/src/Xcm/v5/Junction/Junction.sol

@@ -12,7 +12,7 @@ import {Address} from "../../../Scale/Address.sol";
 import {Compact} from "../../../Scale/Compact.sol";
 
 /// @dev Discriminant for the different types of junctions in XCM v5. Each variant corresponds to a specific structure of the payload.
-enum JunctionType {
+enum JunctionVariant {
     /// @custom:variant An indexed parachain belonging to and operated by the context.
     Parachain,
     /// @custom:variantA 32-byte identifier for an account of a specific network that is respected as a sovereign endpoint within the context.
@@ -35,6 +35,12 @@ enum JunctionType {
     GlobalConsensus
 }
 
+/// @notice Parameters for a `Parachain` junction.
+struct ParachainParams {
+    /// @custom:property The parachain identifier.
+    uint32 parachainId;
+}
+
 /// @notice Parameters for an `AccountId32` junction, containing optional network information and a 32-byte account identifier.
 struct AccountId32Params {
     /// @custom:property Indicates whether the junction includes network information. If true, the `network` field contains valid data; if false, the `network` field should be ignored.
@@ -81,12 +87,6 @@ struct GeneralKeyParams {
     bytes32 key;
 }
 
-/// @notice Parameters for a `Parachain` junction.
-struct ParachainParams {
-    /// @custom:property The parachain identifier.
-    uint32 parachainId;
-}
-
 /// @notice Parameters for a `PalletInstance` junction.
 struct PalletInstanceParams {
     /// @custom:property The pallet instance index.
@@ -101,9 +101,9 @@ struct GeneralIndexParams {
 
 /// @notice A single item in a path to describe the relative location of a consensus system. Each item assumes a pre-existing location as its context and is defined in terms of it.
 struct Junction {
-    /// @custom:property jType The type of the junction, determining how to interpret the payload. See `JunctionType` enum for possible values.
-    JunctionType jType;
-    /// @custom:property payload The SCALE-encoded data specific to the junction type. The structure of this data varies based on `jType`.
+    /// @custom:property variant The type of the junction, determining how to interpret the payload. See `JunctionVariant` enum for possible values.
+    JunctionVariant variant;
+    /// @custom:property payload The SCALE-encoded data specific to the junction type. The structure of this data varies based on `variant`.
     bytes payload;
 }
 
@@ -123,68 +123,52 @@ function parachain(
 ) pure returns (Junction memory) {
     return
         Junction({
-            jType: JunctionType.Parachain,
+            variant: JunctionVariant.Parachain,
             payload: Compact.encode(params.parachainId)
         });
 }
 
 /// @notice Creates an `AccountId32` junction with the specified parameters.
-/// @param hasNetwork A boolean indicating whether the junction includes network information.
-/// @param network The `NetworkId` associated with the account, if `hasNetwork` is true.
-/// @param id The 32-byte identifier for the account.
+/// @param params Parameters for the account-id-32 variant.
 /// @return A `Junction` struct representing the `AccountId32` junction with the provided parameters.
 function accountId32(
-    bool hasNetwork,
-    NetworkId memory network,
-    bytes32 id
+    AccountId32Params memory params
 ) pure returns (Junction memory) {
-    return
-        Junction({
-            jType: JunctionType.AccountId32,
-            payload: abi.encodePacked(hasNetwork, network.encode(), id.encode())
-        });
+    bytes memory payload = abi.encodePacked(params.hasNetwork);
+    if (params.hasNetwork) {
+        payload = abi.encodePacked(payload, params.network.encode());
+    }
+    payload = abi.encodePacked(payload, params.id);
+    return Junction({variant: JunctionVariant.AccountId32, payload: payload});
 }
 
 /// @notice Creates an `AccountIndex64` junction with the specified parameters.
-/// @param hasNetwork A boolean indicating whether the junction includes network information.
-/// @param network The `NetworkId` associated with the account, if `hasNetwork` is true.
-/// @param index The 64-bit index identifier for the account.
+/// @param params Parameters for the account-index-64 variant.
 /// @return A `Junction` struct representing the `AccountIndex64` junction with the provided parameters.
 function accountIndex64(
-    bool hasNetwork,
-    NetworkId memory network,
-    uint64 index
+    AccountIndex64Params memory params
 ) pure returns (Junction memory) {
+    bytes memory payload = abi.encodePacked(params.hasNetwork);
+    if (params.hasNetwork) {
+        payload = abi.encodePacked(payload, params.network.encode());
+    }
+    payload = abi.encodePacked(payload, Compact.encode(params.index));
     return
-        Junction({
-            jType: JunctionType.AccountIndex64,
-            payload: abi.encodePacked(
-                hasNetwork,
-                network.encode(),
-                Compact.encode(index)
-            )
-        });
+        Junction({variant: JunctionVariant.AccountIndex64, payload: payload});
 }
 
 /// @notice Creates an `AccountKey20` junction with the specified parameters.
-/// @param hasNetwork A boolean indicating whether the junction includes network information.
-/// @param network The `NetworkId` associated with the account, if `hasNetwork` is true.
-/// @param key The 20-byte key identifier for the account, represented as an `address` in Solidity.
+/// @param params Parameters for the account-key-20 variant.
 /// @return A `Junction` struct representing the `AccountKey20` junction with the provided parameters.
 function accountKey20(
-    bool hasNetwork,
-    NetworkId memory network,
-    address key
+    AccountKey20Params memory params
 ) pure returns (Junction memory) {
-    return
-        Junction({
-            jType: JunctionType.AccountKey20,
-            payload: abi.encodePacked(
-                hasNetwork,
-                network.encode(),
-                key.encode()
-            )
-        });
+    bytes memory payload = abi.encodePacked(params.hasNetwork);
+    if (params.hasNetwork) {
+        payload = abi.encodePacked(payload, params.network.encode());
+    }
+    payload = abi.encodePacked(payload, params.key.encode());
+    return Junction({variant: JunctionVariant.AccountKey20, payload: payload});
 }
 
 /// @notice Creates a `PalletInstance` junction with the given instance index.
@@ -195,7 +179,7 @@ function palletInstance(
 ) pure returns (Junction memory) {
     return
         Junction({
-            jType: JunctionType.PalletInstance,
+            variant: JunctionVariant.PalletInstance,
             payload: abi.encodePacked(params.instance)
         });
 }
@@ -208,45 +192,47 @@ function generalIndex(
 ) pure returns (Junction memory) {
     return
         Junction({
-            jType: JunctionType.GeneralIndex,
+            variant: JunctionVariant.GeneralIndex,
             payload: Compact.encode(params.index)
         });
 }
 
 /// @notice Creates a `GeneralKey` junction with the given key.
-/// @param length The byte array acting as a key within the context location. This should be between 1 and 32 bytes in length.
-/// @param key The byte array acting as a key within the context location, represented as a `bytes32` in Solidity. Only the first `length` bytes will be used.
+/// @param params Parameters for the general-key variant.
 /// @return A `Junction` struct representing the general key junction with the provided parameters.
-function generalKey(uint8 length, bytes32 key) pure returns (Junction memory) {
-    if (length == 0 || length > 32 || key.length != length)
-        revert InvalidJunctionPayload();
+function generalKey(
+    GeneralKeyParams memory params
+) pure returns (Junction memory) {
+    if (
+        params.length == 0 ||
+        params.length > 32 ||
+        params.key.length != params.length
+    ) revert InvalidJunctionPayload();
     return
         Junction({
-            jType: JunctionType.GeneralKey,
-            payload: abi.encodePacked(length, key)
+            variant: JunctionVariant.GeneralKey,
+            payload: abi.encodePacked(params.length, params.key)
         });
 }
 
 /// @notice Creates an `OnlyChild` junction, which represents the unambiguous child in the context.
 /// @return A `Junction` struct representing the `OnlyChild` junction, with an empty payload.
 function onlyChild() pure returns (Junction memory) {
-    return Junction({jType: JunctionType.OnlyChild, payload: ""});
+    return Junction({variant: JunctionVariant.OnlyChild, payload: ""});
 }
 
 /// @notice Creates a `Plurality` junction with the specified body ID and body part.
-/// @param id The identifier for the body of the plurality, represented as a `BodyId` struct.
-/// @param part The part of the body that is relevant for this junction, represented as a `BodyPart` struct.
+/// @param params Parameters for the plurality variant.
 /// @return A `Junction` struct representing the `Plurality` junction with the provided parameters.
 function plurality(
-    BodyId memory id,
-    BodyPart memory part
+    PluralityParams memory params
 ) pure returns (Junction memory) {
     return
         Junction({
-            jType: JunctionType.Plurality,
+            variant: JunctionVariant.Plurality,
             payload: abi.encodePacked(
-                BodyIdCodec.encode(id),
-                BodyPartCodec.encode(part)
+                BodyIdCodec.encode(params.id),
+                BodyPartCodec.encode(params.part)
             )
         });
 }
@@ -254,5 +240,5 @@ function plurality(
 /// @notice Creates a `GlobalConsensus` junction, which represents a global network capable of externalizing its own consensus.
 /// @return A `Junction` struct representing the `GlobalConsensus` junction, with an empty payload.
 function globalConsensus() pure returns (Junction memory) {
-    return Junction({jType: JunctionType.GlobalConsensus, payload: ""});
+    return Junction({variant: JunctionVariant.GlobalConsensus, payload: ""});
 }

package/src/Xcm/v5/Junction/JunctionCodec.sol

@@ -12,13 +12,18 @@ import {Address} from "../../../Scale/Address.sol";
 import {Compact} from "../../../Scale/Compact.sol";
 import {
     Junction,
-    JunctionType,
+    JunctionVariant,
+    ParachainParams,
     AccountId32Params,
     PluralityParams,
     AccountIndex64Params,
     AccountKey20Params,
-    GeneralKeyParams
+    GeneralKeyParams,
+    PalletInstanceParams,
+    GeneralIndexParams
 } from "./Junction.sol";
+import {BytesUtils} from "../../../Utils/BytesUtils.sol";
+import {UnsignedUtils} from "../../../Utils/UnsignedUtils.sol";
 
 /// @title SCALE Codec for XCM v5 `Junction`
 /// @notice SCALE-compliant encoder/decoder for the `Junction` type.
@@ -26,7 +31,7 @@ import {
 /// @dev XCM v5 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v5/index.html
 library JunctionCodec {
     error InvalidJunctionLength();
-    error InvalidJunctionType(uint8 jType);
+    error InvalidJunctionVariant(uint8 variant);
     error InvalidJunctionPayload();
 
     /// @notice Encodes a `Junction` struct into a byte array suitable for SCALE encoding.
@@ -35,7 +40,7 @@ library JunctionCodec {
     function encode(
         Junction memory junction
     ) internal pure returns (bytes memory) {
-        return abi.encodePacked(uint8(junction.jType), junction.payload);
+        return abi.encodePacked(uint8(junction.variant), junction.payload);
     }
 
     /// @notice Returns the number of bytes that a `Junction` struct would occupy when SCALE-encoded, starting from the specified offset.
@@ -47,44 +52,41 @@ library JunctionCodec {
         uint256 offset
     ) internal pure returns (uint256) {
         if (offset >= data.length) revert InvalidJunctionLength();
-        uint8 jType;
-        assembly {
-            jType := shr(248, mload(add(add(data, 32), offset)))
-        }
+        uint8 variant = uint8(data[offset]);
         uint256 payloadLength;
         ++offset; // Move past the type byte
-        if (jType == uint8(JunctionType.Parachain)) {
+        if (variant == uint8(JunctionVariant.Parachain)) {
             payloadLength = Compact.encodedSizeAt(data, offset);
-        } else if (jType == uint8(JunctionType.AccountId32)) {
+        } else if (variant == uint8(JunctionVariant.AccountId32)) {
             payloadLength = _innerNetworkIdSize(data, offset) + 32; // for the account ID;
-        } else if (jType == uint8(JunctionType.AccountIndex64)) {
+        } else if (variant == uint8(JunctionVariant.AccountIndex64)) {
             payloadLength = _innerNetworkIdSize(data, offset);
             payloadLength += Compact.encodedSizeAt(
                 data,
                 offset + payloadLength
             ); // for the account index
-        } else if (jType == uint8(JunctionType.AccountKey20)) {
+        } else if (variant == uint8(JunctionVariant.AccountKey20)) {
             payloadLength = _innerNetworkIdSize(data, offset) + 20; // for the account key;
-        } else if (jType == uint8(JunctionType.PalletInstance)) {
+        } else if (variant == uint8(JunctionVariant.PalletInstance)) {
             payloadLength = 1;
-        } else if (jType == uint8(JunctionType.GeneralIndex)) {
+        } else if (variant == uint8(JunctionVariant.GeneralIndex)) {
             payloadLength = Compact.encodedSizeAt(data, offset);
-        } else if (jType == uint8(JunctionType.GeneralKey)) {
+        } else if (variant == uint8(JunctionVariant.GeneralKey)) {
             if (offset >= data.length) revert InvalidJunctionLength();
             uint8 length = uint8(data[offset]);
             payloadLength = 1 + length; // 1 byte for the length + the key bytes
         } else if (
-            jType == uint8(JunctionType.OnlyChild) ||
-            jType == uint8(JunctionType.GlobalConsensus)
+            variant == uint8(JunctionVariant.OnlyChild) ||
+            variant == uint8(JunctionVariant.GlobalConsensus)
         ) {
             payloadLength = 0;
-        } else if (jType == uint8(JunctionType.Plurality)) {
+        } else if (variant == uint8(JunctionVariant.Plurality)) {
             uint256 innerLength = BodyIdCodec.encodedSizeAt(data, offset);
             payloadLength =
                 innerLength +
                 BodyPartCodec.encodedSizeAt(data, offset + innerLength);
         } else {
-            revert InvalidJunctionType(jType);
+            revert InvalidJunctionVariant(variant);
         }
 
         return 1 + payloadLength; // 1 byte for the type + payload length
@@ -109,36 +111,25 @@ library JunctionCodec {
         bytes memory data,
         uint256 offset
     ) internal pure returns (Junction memory junction, uint256 bytesRead) {
-        if (offset >= data.length) revert InvalidJunctionLength();
-        uint8 jType;
-        assembly {
-            jType := shr(248, mload(add(add(data, 32), offset)))
-        }
         uint256 payloadLength = encodedSizeAt(data, offset) - 1; // Subtract 1 byte for the type
-        bytes memory payload = new bytes(payloadLength);
-        for (uint256 i = 0; i < payloadLength; i++) {
-            payload[i] = data[offset + 1 + i];
-        }
-        junction = Junction({jType: JunctionType(jType), payload: payload});
+        uint8 variant = uint8(data[offset]);
+        bytes memory payload = BytesUtils.copy(data, offset + 1, payloadLength);
+        junction = Junction({
+            variant: JunctionVariant(variant),
+            payload: payload
+        });
         bytesRead = 1 + payload.length;
     }
 
     /// @notice Decodes a `Parachain` junction from a given `Junction` struct, extracting the parachain ID.
     /// @param junction The `Junction` struct to decode, which should represent a `Parachain` junction.
-    /// @return parachainId The ID of the parachain extracted from the junction's payload.
+    /// @return params A `ParachainParams` struct containing the decoded parachain ID.
     function asParachain(
         Junction memory junction
-    ) internal pure returns (uint32 parachainId) {
-        if (junction.jType != JunctionType.Parachain)
-            revert InvalidJunctionType(uint8(junction.jType));
-        if (junction.payload.length != 4) revert InvalidJunctionPayload();
+    ) internal pure returns (ParachainParams memory params) {
+        _assertVariant(junction, JunctionVariant.Parachain);
         (uint256 decodedParachain, ) = Compact.decode(junction.payload);
-        if (decodedParachain > type(uint32).max) {
-            revert InvalidJunctionPayload();
-        }
-        unchecked {
-            parachainId = uint32(decodedParachain);
-        }
+        params.parachainId = UnsignedUtils.toU32(decodedParachain);
     }
 
     /// @notice Decodes an `AccountId32` junction from a given `Junction` struct, extracting the network information and account ID.
@@ -147,28 +138,18 @@ library JunctionCodec {
     function asAccountId32(
         Junction memory junction
     ) internal pure returns (AccountId32Params memory params) {
-        if (junction.jType != JunctionType.AccountId32)
-            revert InvalidJunctionType(uint8(junction.jType));
-        if (junction.payload.length != 33 && junction.payload.length != 34)
-            revert InvalidJunctionPayload();
-        bool hasNetwork = junction.payload[0] != 0;
+        _assertVariant(junction, JunctionVariant.AccountId32);
+        params.hasNetwork = junction.payload[0] != 0;
         uint256 offset = 1;
-        NetworkId memory network;
         uint256 bytesRead;
-        if (hasNetwork) {
-            (network, bytesRead) = NetworkIdCodec.decodeAt(
+        if (params.hasNetwork) {
+            (params.network, bytesRead) = NetworkIdCodec.decodeAt(
                 junction.payload,
                 offset
             );
             offset += bytesRead;
         }
-        bytes32 id = Bytes32.decodeAt(junction.payload, offset);
-        return
-            AccountId32Params({
-                hasNetwork: hasNetwork,
-                network: network,
-                id: id
-            });
+        params.id = Bytes32.decodeAt(junction.payload, offset);
     }
 
     /// @notice Decodes an `AccountIndex64` junction from a given `Junction` struct, extracting the network information and account index.
@@ -177,35 +158,19 @@ library JunctionCodec {
     function asAccountIndex64(
         Junction memory junction
     ) internal pure returns (AccountIndex64Params memory params) {
-        if (junction.jType != JunctionType.AccountIndex64)
-            revert InvalidJunctionType(uint8(junction.jType));
-        if (junction.payload.length != 9 && junction.payload.length != 10)
-            revert InvalidJunctionPayload();
-        bool hasNetwork = junction.payload[0] != 0;
+        _assertVariant(junction, JunctionVariant.AccountIndex64);
+        params.hasNetwork = junction.payload[0] != 0;
         uint256 offset = 1;
-        NetworkId memory network;
         uint256 bytesRead;
-        if (hasNetwork) {
-            (network, bytesRead) = NetworkIdCodec.decodeAt(
+        if (params.hasNetwork) {
+            (params.network, bytesRead) = NetworkIdCodec.decodeAt(
                 junction.payload,
                 offset
             );
             offset += bytesRead;
         }
         (uint256 decodedIndex, ) = Compact.decodeAt(junction.payload, offset);
-        if (decodedIndex > type(uint64).max) {
-            revert InvalidJunctionPayload();
-        }
-        uint64 index;
-        unchecked {
-            index = uint64(decodedIndex);
-        }
-        return
-            AccountIndex64Params({
-                hasNetwork: hasNetwork,
-                network: network,
-                index: index
-            });
+        params.index = UnsignedUtils.toU64(decodedIndex);
     }
 
     /// @notice Decodes an `AccountKey20` junction from a given `Junction` struct, extracting the network information and account key.
@@ -214,58 +179,39 @@ library JunctionCodec {
     function asAccountKey20(
         Junction memory junction
     ) internal pure returns (AccountKey20Params memory params) {
-        if (junction.jType != JunctionType.AccountKey20)
-            revert InvalidJunctionType(uint8(junction.jType));
-        if (junction.payload.length != 21 && junction.payload.length != 22)
-            revert InvalidJunctionPayload();
-        bool hasNetwork = junction.payload[0] != 0;
+        _assertVariant(junction, JunctionVariant.AccountKey20);
+        params.hasNetwork = junction.payload[0] != 0;
         uint256 offset = 1;
-        NetworkId memory network;
         uint256 bytesRead;
-        if (hasNetwork) {
-            (network, bytesRead) = NetworkIdCodec.decodeAt(
+        if (params.hasNetwork) {
+            (params.network, bytesRead) = NetworkIdCodec.decodeAt(
                 junction.payload,
                 offset
             );
             offset += bytesRead;
         }
-        address key = Address.decodeAt(junction.payload, offset);
-        return
-            AccountKey20Params({
-                hasNetwork: hasNetwork,
-                network: network,
-                key: key
-            });
+        params.key = Address.decodeAt(junction.payload, offset);
     }
 
     /// @notice Decodes a `PalletInstance` junction from a given `Junction` struct, extracting the pallet instance index.
     /// @param junction The `Junction` struct to decode, which should represent a `PalletInstance` junction.
-    /// @return instance The index of the pallet instance extracted from the junction's payload.
+    /// @return params A `PalletInstanceParams` struct containing the decoded pallet instance index.
     function asPalletInstance(
         Junction memory junction
-    ) internal pure returns (uint8 instance) {
-        if (junction.jType != JunctionType.PalletInstance)
-            revert InvalidJunctionType(uint8(junction.jType));
-        if (junction.payload.length != 1) revert InvalidJunctionPayload();
-        return uint8(junction.payload[0]);
+    ) internal pure returns (PalletInstanceParams memory params) {
+        _assertVariant(junction, JunctionVariant.PalletInstance);
+        params.instance = uint8(junction.payload[0]);
     }
 
     /// @notice Decodes a `GeneralIndex` junction from a given `Junction` struct, extracting the general index.
     /// @param junction The `Junction` struct to decode, which should represent a `GeneralIndex` junction.
-    /// @return index The general index extracted from the junction's payload.
+    /// @return params A `GeneralIndexParams` struct containing the decoded general index.
     function asGeneralIndex(
         Junction memory junction
-    ) internal pure returns (uint128 index) {
-        if (junction.jType != JunctionType.GeneralIndex)
-            revert InvalidJunctionType(uint8(junction.jType));
-        if (junction.payload.length == 0) revert InvalidJunctionPayload();
+    ) internal pure returns (GeneralIndexParams memory params) {
+        _assertVariant(junction, JunctionVariant.GeneralIndex);
         (uint256 decodedIndex, ) = Compact.decode(junction.payload);
-        if (decodedIndex > type(uint128).max) {
-            revert InvalidJunctionPayload();
-        }
-        unchecked {
-            index = uint128(decodedIndex);
-        }
+        params.index = UnsignedUtils.toU128(decodedIndex);
     }
 
     /// @notice Decodes a `GeneralKey` junction from a given `Junction` struct, extracting the key.
@@ -274,14 +220,9 @@ library JunctionCodec {
     function asGeneralKey(
         Junction memory junction
     ) internal pure returns (GeneralKeyParams memory params) {
-        if (junction.jType != JunctionType.GeneralKey)
-            revert InvalidJunctionType(uint8(junction.jType));
-        if (junction.payload.length == 0) revert InvalidJunctionPayload();
-        uint8 length = uint8(junction.payload[0]);
-        if (length == 0 || length > 32 || junction.payload.length != length + 1)
-            revert InvalidJunctionPayload();
-        bytes32 key = Bytes32.decodeAt(junction.payload, 1);
-        return GeneralKeyParams({length: length, key: key});
+        _assertVariant(junction, JunctionVariant.GeneralKey);
+        params.length = uint8(junction.payload[0]);
+        params.key = Bytes32.decodeAt(junction.payload, 1);
     }
 
     /// @notice Decodes a `Plurality` junction from a given `Junction` struct, extracting the body ID and body part.
@@ -290,28 +231,15 @@ library JunctionCodec {
     function asPlurality(
         Junction memory junction
     ) internal pure returns (PluralityParams memory params) {
-        if (junction.jType != JunctionType.Plurality)
-            revert InvalidJunctionType(uint8(junction.jType));
-        if (junction.payload.length == 0) revert InvalidJunctionPayload();
+        _assertVariant(junction, JunctionVariant.Plurality);
         uint256 offset = 0;
-        BodyId memory id;
         uint256 bytesRead;
-        (id, bytesRead) = BodyIdCodec.decodeAt(junction.payload, offset);
+        (params.id, bytesRead) = BodyIdCodec.decodeAt(junction.payload, offset);
         offset += bytesRead;
-        BodyPart memory part;
-        (part, bytesRead) = BodyPartCodec.decodeAt(junction.payload, offset);
-        return PluralityParams({id: id, part: part});
-    }
-
-    /// @notice Decodes an `GlobalConsensus` junction from a given `Junction` struct and extracts the `NetworkId`.
-    /// @param junction The `Junction` struct to decode, which should represent a `GlobalConsensus` junction.
-    /// @return networkId The `NetworkId` extracted from the junction's payload, representing the global network's consensus.
-    function asGlobalConsensus(
-        Junction memory junction
-    ) internal pure returns (NetworkId memory networkId) {
-        if (junction.jType != JunctionType.GlobalConsensus)
-            revert InvalidJunctionType(uint8(junction.jType));
-        (networkId, ) = NetworkIdCodec.decode(junction.payload);
+        (params.part, bytesRead) = BodyPartCodec.decodeAt(
+            junction.payload,
+            offset
+        );
     }
 
     function _innerNetworkIdSize(
@@ -326,4 +254,13 @@ library JunctionCodec {
         }
         return size;
     }
+
+    function _assertVariant(
+        Junction memory junction,
+        JunctionVariant expected
+    ) private pure {
+        if (junction.variant != expected) {
+            revert InvalidJunctionVariant(uint8(junction.variant));
+        }
+    }
 }

package/src/Xcm/v5/Junctions/Junctions.sol

@@ -10,3 +10,37 @@ struct Junctions {
     /// @custom:property The actual junction data
     Junction[] items;
 }
+
+error InvalidJunctionsCount(uint8 count);
+
+/// @notice Creates a `Here` junctions struct.
+/// @return A `Junctions` struct representing the `Here` variant.
+function here() pure returns (Junctions memory) {
+    return Junctions({count: 0, items: new Junction[](0)});
+}
+
+/// @notice Creates a `Junctions` struct from a single `Junction`, representing the `X1` variant.
+/// @param junction The `Junction` to include in the `Junctions`.
+/// @return A `Junctions` struct containing the provided `Junction`.
+function fromJunction(
+    Junction memory junction
+) pure returns (Junctions memory) {
+    Junction[] memory js = new Junction[](1);
+    js[0] = junction;
+    return Junctions({count: 1, items: js});
+}
+
+/// @notice Creates a `Junctions` struct with the given junctions.
+/// @param junctions An array of `Junction` structs to include in the `Junctions`.
+/// @return A `Junctions` struct containing the provided junctions.
+function fromJunctionArr(
+    Junction[] memory junctions
+) pure returns (Junctions memory) {
+    if (junctions.length == 0) {
+        return here();
+    }
+    if (junctions.length > 8) {
+        revert InvalidJunctionsCount(uint8(junctions.length));
+    }
+    return Junctions({count: uint8(junctions.length), items: junctions});
+}

package/src/Xcm/v5/Junctions/JunctionsCodec.sol

@@ -13,24 +13,6 @@ library JunctionsCodec {
     error InvalidJunctionsLength(uint8 count);
     error InvalidJunctionsCount(uint8 count);
 
-    /// @notice Creates a `Here` junctions struct.
-    function here() internal pure returns (Junctions memory) {
-        return Junctions({count: 0, items: new Junction[](0)});
-    }
-
-    /// @notice Creates a `Junctions` struct with the given junctions.
-    function junction(
-        Junction[] memory junctions
-    ) internal pure returns (Junctions memory) {
-        if (junctions.length == 0) {
-            return here();
-        }
-        if (junctions.length > 8) {
-            revert InvalidJunctionsCount(uint8(junctions.length));
-        }
-        return Junctions({count: uint8(junctions.length), items: junctions});
-    }
-
     /// @notice Encodes a Junctions struct into bytes.
     /// @param junctions The Junctions struct to encode.
     /// @return SCALE-encoded byte sequence representing the Junctions.

package/src/Xcm/v5/Location/Location.sol

@@ -3,6 +3,8 @@ pragma solidity ^0.8.28;
 
 import {Junctions} from "../Junctions/Junctions.sol";
 
+import {here} from "../Junctions/Junctions.sol";
+
 /// @notice A relative path between state-bearing consensus systems.
 struct Location {
     /// @custom:property The number of parent junctions at the beginning of this Location.
@@ -10,3 +12,9 @@ struct Location {
     /// @custom:property The interior (i.e. non-parent) junctions that this Location contains. See `Junctions` struct for details.
     Junctions interior;
 }
+
+/// @notice Creates a `Location` struct representing the parent location (i.e., one level up in the hierarchy).
+/// @return A `Location` struct with `parents` set to 1 and an empty `interior`.
+function parent() pure returns (Location memory) {
+    return Location({parents: 1, interior: here()});
+}