solidity-scale-codec 0.1.3 → 0.3.0

package/src/Xcm/v5/Instruction/InstructionCodec.sol

@@ -0,0 +1,321 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Instruction, InstructionType} from "./Instruction.sol";
+import {AssetsCodec} from "../Assets/AssetsCodec.sol";
+import {AssetCodec} from "../Asset/AssetCodec.sol";
+import {LocationCodec} from "../Location/LocationCodec.sol";
+import {JunctionsCodec} from "../Junctions/JunctionsCodec.sol";
+import {JunctionCodec} from "../Junction/JunctionCodec.sol";
+import {AssetFilterCodec} from "../AssetFilter/AssetFilterCodec.sol";
+import {AssetTransferFilterCodec} from "../AssetTransferFilter/AssetTransferFilterCodec.sol";
+import {QueryResponseInfoCodec} from "../QueryResponseInfo/QueryResponseInfoCodec.sol";
+import {ResponseCodec} from "../Response/ResponseCodec.sol";
+import {XcmErrorCodec} from "../XcmError/XcmErrorCodec.sol";
+import {NetworkIdCodec} from "../NetworkId/NetworkIdCodec.sol";
+import {OriginKindCodec} from "../OriginKind/OriginKindCodec.sol";
+import {WeightCodec} from "../Weight/WeightCodec.sol";
+import {WeightLimitCodec} from "../WeightLimit/WeightLimitCodec.sol";
+import {HintCodec} from "../Hint/HintCodec.sol";
+import {MaybeErrorCodeCodec} from "../../v3/MaybeErrorCode/MaybeErrorCodeCodec.sol";
+import {MAX_ASSET_TRANSFER_FILTERS, HINT_NUM_VARIANTS} from "../Constants.sol";
+
+import {Compact} from "../../../Scale/Compact.sol";
+import {Bool} from "../../../Scale/Bool/Bool.sol";
+import {Bytes} from "../../../Scale/Bytes/Bytes.sol";
+
+/// @title SCALE Codec for XCM v5 `Instruction`
+/// @notice SCALE-compliant encoder/decoder for the `Instruction` 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 InstructionCodec {
+    error InvalidInstructionLength();
+    error InvalidInstructionType(uint8 iType);
+    error InvalidInstructionPayload();
+
+    /// @notice Encodes an `Instruction` into SCALE bytes.
+    /// @param instruction The `Instruction` struct to encode.
+    /// @return SCALE-encoded bytes representing the instruction.
+    function encode(
+        Instruction memory instruction
+    ) internal pure returns (bytes memory) {
+        return abi.encodePacked(uint8(instruction.iType), instruction.payload);
+    }
+
+    /// @notice Returns the number of bytes that an `Instruction` occupies when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded instruction.
+    /// @param offset The starting index in `data` from which to calculate the encoded size.
+    /// @return The number of bytes occupied by the encoded instruction.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (data.length < offset + 1) revert InvalidInstructionLength();
+
+        uint8 iTypeRaw = uint8(data[offset]);
+        if (iTypeRaw > uint8(InstructionType.SetHints)) {
+            revert InvalidInstructionType(iTypeRaw);
+        }
+
+        InstructionType iType = InstructionType(iTypeRaw);
+        uint256 pos = offset + 1;
+
+        if (
+            iType == InstructionType.WithdrawAsset ||
+            iType == InstructionType.ReserveAssetDeposited ||
+            iType == InstructionType.ReceiveTeleportedAsset ||
+            iType == InstructionType.BurnAsset ||
+            iType == InstructionType.ExpectAsset
+        ) {
+            pos += AssetsCodec.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.QueryResponse) {
+            pos += Compact.encodedSizeAt(data, pos);
+            pos += ResponseCodec.encodedSizeAt(data, pos);
+            pos += WeightCodec.encodedSizeAt(data, pos);
+            bool hasQuerier = Bool.decodeAt(data, pos);
+            pos += 1;
+            if (hasQuerier) {
+                pos += LocationCodec.encodedSizeAt(data, pos);
+            }
+        } else if (iType == InstructionType.TransferAsset) {
+            pos += AssetsCodec.encodedSizeAt(data, pos);
+            pos += LocationCodec.encodedSizeAt(data, pos);
+        } else if (
+            iType == InstructionType.TransferReserveAsset ||
+            iType == InstructionType.DepositReserveAsset ||
+            iType == InstructionType.InitiateReserveWithdraw ||
+            iType == InstructionType.InitiateTeleport
+        ) {
+            if (iType == InstructionType.TransferReserveAsset) {
+                pos += AssetsCodec.encodedSizeAt(data, pos);
+                pos += LocationCodec.encodedSizeAt(data, pos);
+            } else {
+                pos += AssetFilterCodec.encodedSizeAt(data, pos);
+                pos += LocationCodec.encodedSizeAt(data, pos);
+            }
+            pos += _xcmEncodedSizeAt(data, pos);
+        } else if (iType == InstructionType.Transact) {
+            pos += OriginKindCodec.encodedSizeAt(data, pos);
+            bool hasFallbackMaxWeight = Bool.decodeAt(data, pos);
+            pos += 1;
+            if (hasFallbackMaxWeight) {
+                pos += WeightCodec.encodedSizeAt(data, pos);
+            }
+            pos += Bytes.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.HrmpNewChannelOpenRequest) {
+            pos += Compact.encodedSizeAt(data, pos);
+            pos += Compact.encodedSizeAt(data, pos);
+            pos += Compact.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.HrmpChannelAccepted) {
+            pos += Compact.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.HrmpChannelClosing) {
+            pos += Compact.encodedSizeAt(data, pos);
+            pos += Compact.encodedSizeAt(data, pos);
+            pos += Compact.encodedSizeAt(data, pos);
+        } else if (
+            iType == InstructionType.ClearOrigin ||
+            iType == InstructionType.RefundSurplus ||
+            iType == InstructionType.ClearError ||
+            iType == InstructionType.UnsubscribeVersion ||
+            iType == InstructionType.ClearTransactStatus ||
+            iType == InstructionType.ClearTopic
+        ) {
+            // no payload
+        } else if (iType == InstructionType.DescendOrigin) {
+            pos += JunctionsCodec.encodedSizeAt(data, pos);
+        } else if (
+            iType == InstructionType.ReportError ||
+            iType == InstructionType.ReportTransactStatus
+        ) {
+            pos += QueryResponseInfoCodec.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.DepositAsset) {
+            pos += AssetFilterCodec.encodedSizeAt(data, pos);
+            pos += LocationCodec.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.ExchangeAsset) {
+            pos += AssetFilterCodec.encodedSizeAt(data, pos);
+            pos += AssetsCodec.encodedSizeAt(data, pos);
+            pos += 1;
+        } else if (iType == InstructionType.ReportHolding) {
+            pos += QueryResponseInfoCodec.encodedSizeAt(data, pos);
+            pos += AssetFilterCodec.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.BuyExecution) {
+            pos += AssetCodec.encodedSizeAt(data, pos);
+            pos += WeightLimitCodec.encodedSizeAt(data, pos);
+        } else if (
+            iType == InstructionType.SetErrorHandler ||
+            iType == InstructionType.SetAppendix
+        ) {
+            pos += _xcmEncodedSizeAt(data, pos);
+        } else if (iType == InstructionType.ClaimAsset) {
+            pos += AssetsCodec.encodedSizeAt(data, pos);
+            pos += LocationCodec.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.Trap) {
+            pos += Compact.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.SubscribeVersion) {
+            pos += Compact.encodedSizeAt(data, pos);
+            pos += WeightCodec.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.ExpectOrigin) {
+            bool hasOrigin = Bool.decodeAt(data, pos);
+            pos += 1;
+            if (hasOrigin) {
+                pos += LocationCodec.encodedSizeAt(data, pos);
+            }
+        } else if (iType == InstructionType.ExpectError) {
+            bool hasError = Bool.decodeAt(data, pos);
+            pos += 1;
+            if (hasError) {
+                pos += Compact.encodedSizeAt(data, pos);
+                pos += XcmErrorCodec.encodedSizeAt(data, pos);
+            }
+        } else if (iType == InstructionType.ExpectTransactStatus) {
+            pos += MaybeErrorCodeCodec.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.QueryPallet) {
+            pos += Bytes.encodedSizeAt(data, pos);
+            pos += QueryResponseInfoCodec.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.ExpectPallet) {
+            pos += Compact.encodedSizeAt(data, pos);
+            pos += Bytes.encodedSizeAt(data, pos);
+            pos += Bytes.encodedSizeAt(data, pos);
+            pos += Compact.encodedSizeAt(data, pos);
+            pos += Compact.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.UniversalOrigin) {
+            pos += JunctionCodec.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.ExportMessage) {
+            pos += NetworkIdCodec.encodedSizeAt(data, pos);
+            pos += JunctionsCodec.encodedSizeAt(data, pos);
+            pos += _xcmEncodedSizeAt(data, pos);
+        } else if (
+            iType == InstructionType.LockAsset ||
+            iType == InstructionType.UnlockAsset ||
+            iType == InstructionType.NoteUnlockable ||
+            iType == InstructionType.RequestUnlock
+        ) {
+            pos += AssetCodec.encodedSizeAt(data, pos);
+            pos += LocationCodec.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.SetFeesMode) {
+            pos += 1;
+        } else if (iType == InstructionType.SetTopic) {
+            if (data.length < pos + 32) revert InvalidInstructionPayload();
+            pos += 32;
+        } else if (iType == InstructionType.AliasOrigin) {
+            pos += LocationCodec.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.UnpaidExecution) {
+            pos += WeightLimitCodec.encodedSizeAt(data, pos);
+            bool hasCheckOrigin = Bool.decodeAt(data, pos);
+            pos += 1;
+            if (hasCheckOrigin) {
+                pos += LocationCodec.encodedSizeAt(data, pos);
+            }
+        } else if (iType == InstructionType.PayFees) {
+            pos += AssetCodec.encodedSizeAt(data, pos);
+        } else if (iType == InstructionType.InitiateTransfer) {
+            pos += LocationCodec.encodedSizeAt(data, pos);
+            bool hasRemoteFees = Bool.decodeAt(data, pos);
+            pos += 1;
+            if (hasRemoteFees) {
+                pos += AssetTransferFilterCodec.encodedSizeAt(data, pos);
+            }
+            pos += 1; // preserveOrigin bool
+            (uint256 assetsCount, uint256 assetsCountBytes) = Compact.decodeAt(
+                data,
+                pos
+            );
+            if (assetsCount > MAX_ASSET_TRANSFER_FILTERS) {
+                revert InvalidInstructionPayload();
+            }
+            pos += assetsCountBytes;
+            for (uint256 i = 0; i < assetsCount; ++i) {
+                pos += AssetTransferFilterCodec.encodedSizeAt(data, pos);
+            }
+            (uint256 remoteXcmLen, uint256 remoteXcmLenBytes) = Compact
+                .decodeAt(data, pos);
+            pos += remoteXcmLenBytes;
+            if (data.length < pos + remoteXcmLen)
+                revert InvalidInstructionPayload();
+            pos += remoteXcmLen;
+        } else if (iType == InstructionType.ExecuteWithOrigin) {
+            bool hasDescendantOrigin = Bool.decodeAt(data, pos);
+            pos += 1;
+            if (hasDescendantOrigin) {
+                pos += JunctionsCodec.encodedSizeAt(data, pos);
+            }
+            pos += _xcmEncodedSizeAt(data, pos);
+        } else if (iType == InstructionType.SetHints) {
+            (uint256 hintsCount, uint256 hintsCountBytes) = Compact.decodeAt(
+                data,
+                pos
+            );
+            if (hintsCount > HINT_NUM_VARIANTS) {
+                revert InvalidInstructionPayload();
+            }
+            pos += hintsCountBytes;
+            for (uint256 i = 0; i < hintsCount; ++i) {
+                pos += HintCodec.encodedSizeAt(data, pos);
+            }
+        }
+
+        return pos - offset;
+    }
+
+    /// @notice Decodes an `Instruction` from SCALE bytes starting at the beginning.
+    /// @param data The byte sequence containing the encoded instruction.
+    /// @return instruction The decoded `Instruction` struct.
+    /// @return bytesRead The number of bytes read.
+    function decode(
+        bytes memory data
+    )
+        internal
+        pure
+        returns (Instruction memory instruction, uint256 bytesRead)
+    {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `Instruction` from SCALE bytes starting at a given offset.
+    /// @param data The byte sequence containing the encoded instruction.
+    /// @param offset The starting index in `data` from which to decode.
+    /// @return instruction The decoded `Instruction` struct.
+    /// @return bytesRead The number of bytes read.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    )
+        internal
+        pure
+        returns (Instruction memory instruction, uint256 bytesRead)
+    {
+        if (data.length < offset + 1) revert InvalidInstructionLength();
+
+        uint8 iTypeRaw = uint8(data[offset]);
+        if (iTypeRaw > uint8(InstructionType.SetHints)) {
+            revert InvalidInstructionType(iTypeRaw);
+        }
+
+        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];
+        }
+
+        instruction = Instruction({
+            iType: InstructionType(iTypeRaw),
+            payload: payload
+        });
+        bytesRead = size;
+    }
+
+    /// @notice Returns the encoded size of an XCM byte sequence at offset.
+    /// @dev XCM encodes as `Vec<Instruction>`: compact count followed by encoded instructions.
+    function _xcmEncodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) private pure returns (uint256) {
+        (uint256 count, uint256 countBytes) = Compact.decodeAt(data, offset);
+        uint256 pos = offset + countBytes;
+        for (uint256 i = 0; i < count; ++i) {
+            pos += encodedSizeAt(data, pos);
+        }
+        return pos - offset;
+    }
+}

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

@@ -0,0 +1,258 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {BodyId} from "../BodyId/BodyId.sol";
+import {BodyIdCodec} from "../BodyId/BodyIdCodec.sol";
+import {BodyPart} from "../BodyPart/BodyPart.sol";
+import {BodyPartCodec} from "../BodyPart/BodyPartCodec.sol";
+import {NetworkId} from "../NetworkId/NetworkId.sol";
+import {NetworkIdCodec} from "../NetworkId/NetworkIdCodec.sol";
+import {Bytes32} from "../../../Scale/Bytes.sol";
+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 {
+    /// @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.
+    AccountId32,
+    /// @custom:variant Generally used when the context is a Frame-based chain.
+    AccountIndex64,
+    /// @custom:variant A 20-byte identifier for an account of a specific network that is respected as a sovereign endpoint within the context.
+    AccountKey20,
+    /// @custom:variant An instanced, indexed pallet that forms a constituent part of the context.
+    PalletInstance,
+    /// @custom:variant A non-descript index within the context location. NOTE: Try to avoid using this and instead use a more specific item.
+    GeneralIndex,
+    /// @custom:variant A nondescript array datum, 32 bytes, acting as a key within the context location. NOTE: Try to avoid using this and instead use a more specific item.
+    GeneralKey,
+    /// @custom:variant The unambiguous child. Not currently used except as a fallback when deriving context.
+    OnlyChild,
+    /// @custom:variant A pluralistic body existing within consensus.
+    Plurality,
+    /// @custom:variant A global network capable of externalizing its own consensus. This is not generally meaningful outside of the universal level.
+    GlobalConsensus
+}
+
+/// @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.
+    bool hasNetwork;
+    /// @custom:property The `NetworkId` associated with the account, See `NetworkId` struct for details. This field is only meaningful if `hasNetwork` is true.
+    NetworkId network;
+    /// @custom:property The 32-byte identifier for the account.
+    bytes32 id;
+}
+
+/// @notice Parameters for an `Plurality` junction
+struct PluralityParams {
+    /// @custom:property The identifier for the body of the plurality. See `BodyId` enum for details.
+    BodyId id;
+    /// @custom:property The part of the body that is relevant for this junction. See `BodyPart` struct for details.
+    BodyPart part;
+}
+
+/// @notice Parameters for an `AccountIndex64` junction, containing optional network information and a 64-bit account index.
+struct AccountIndex64Params {
+    /// @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.
+    bool hasNetwork;
+    /// @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.
+    NetworkId network;
+    /// @custom:property The 8-byte index identifier for the account.
+    uint64 index;
+}
+
+/// @notice Parameters for an `AccountKey20` junction, containing optional network information and a 20-byte account key.
+struct AccountKey20Params {
+    /// @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.
+    bool hasNetwork;
+    /// @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.
+    NetworkId network;
+    /// @custom:property The 20-byte key identifier for the account, represented as an `address` in Solidity.
+    address key;
+}
+
+/// @notice Parameters for an `GeneralKey` junction
+struct GeneralKeyParams {
+    /// @custom:property The length of the byte array acting as a key within the context location. This should be between 1 and 32, inclusive, to ensure valid encoding and decoding.
+    uint8 length;
+    /// @custom:property The byte array acting as a key within the context location.
+    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.
+    uint8 instance;
+}
+
+/// @notice Parameters for a `GeneralIndex` junction.
+struct GeneralIndexParams {
+    /// @custom:property The general compact index within context.
+    uint128 index;
+}
+
+/// @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`.
+    bytes payload;
+}
+
+error InvalidJunctionPayload();
+
+using Address for address;
+using Bytes32 for bytes32;
+using NetworkIdCodec for NetworkId;
+
+// ============ Factory Functions ============
+
+/// @notice Creates a `Parachain` junction with the given parachain ID.
+/// @param params Parameters for the parachain variant.
+/// @return A `Junction` struct representing the parachain junction.
+function parachain(
+    ParachainParams memory params
+) pure returns (Junction memory) {
+    return
+        Junction({
+            jType: JunctionType.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.
+/// @return A `Junction` struct representing the `AccountId32` junction with the provided parameters.
+function accountId32(
+    bool hasNetwork,
+    NetworkId memory network,
+    bytes32 id
+) pure returns (Junction memory) {
+    return
+        Junction({
+            jType: JunctionType.AccountId32,
+            payload: abi.encodePacked(hasNetwork, network.encode(), id.encode())
+        });
+}
+
+/// @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.
+/// @return A `Junction` struct representing the `AccountIndex64` junction with the provided parameters.
+function accountIndex64(
+    bool hasNetwork,
+    NetworkId memory network,
+    uint64 index
+) pure returns (Junction memory) {
+    return
+        Junction({
+            jType: JunctionType.AccountIndex64,
+            payload: abi.encodePacked(
+                hasNetwork,
+                network.encode(),
+                Compact.encode(index)
+            )
+        });
+}
+
+/// @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.
+/// @return A `Junction` struct representing the `AccountKey20` junction with the provided parameters.
+function accountKey20(
+    bool hasNetwork,
+    NetworkId memory network,
+    address key
+) pure returns (Junction memory) {
+    return
+        Junction({
+            jType: JunctionType.AccountKey20,
+            payload: abi.encodePacked(
+                hasNetwork,
+                network.encode(),
+                key.encode()
+            )
+        });
+}
+
+/// @notice Creates a `PalletInstance` junction with the given instance index.
+/// @param params Parameters for the pallet-instance variant.
+/// @return A `Junction` struct representing the pallet instance junction.
+function palletInstance(
+    PalletInstanceParams memory params
+) pure returns (Junction memory) {
+    return
+        Junction({
+            jType: JunctionType.PalletInstance,
+            payload: abi.encodePacked(params.instance)
+        });
+}
+
+/// @notice Creates a `GeneralIndex` junction with the given index.
+/// @param params Parameters for the general-index variant.
+/// @return A `Junction` struct representing the general index junction.
+function generalIndex(
+    GeneralIndexParams memory params
+) pure returns (Junction memory) {
+    return
+        Junction({
+            jType: JunctionType.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.
+/// @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();
+    return
+        Junction({
+            jType: JunctionType.GeneralKey,
+            payload: abi.encodePacked(length, 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: ""});
+}
+
+/// @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.
+/// @return A `Junction` struct representing the `Plurality` junction with the provided parameters.
+function plurality(
+    BodyId memory id,
+    BodyPart memory part
+) pure returns (Junction memory) {
+    return
+        Junction({
+            jType: JunctionType.Plurality,
+            payload: abi.encodePacked(
+                BodyIdCodec.encode(id),
+                BodyPartCodec.encode(part)
+            )
+        });
+}
+
+/// @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: ""});
+}