@bcts/frost-hubert 1.0.0-alpha.22 → 1.0.0-beta.0

package/dist/common-lKP5EzHy.cjs

@@ -0,0 +1,372 @@
+const require_chunk = require("./chunk-CZWwpsFl.cjs");
+const require_proposed_participant = require("./proposed-participant-Dm1Eq6mX.cjs");
+const require_registry_index = require("./registry/index.cjs");
+let _bcts_uniform_resources = require("@bcts/uniform-resources");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path, 1);
+//#region src/cmd/dkg/common.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+*
+* Common utilities for DKG commands.
+*
+* Port of cmd/dkg/common.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Parse an ARID from a UR string.
+*
+* Mirrors Rust `parse_arid_ur` (`cmd/common.rs:27-43`):
+*
+* 1. Trim and reject empty input.
+* 2. Parse as a UR; require `ur_type` of `"arid"`.
+* 3. Try `ARID::try_from(cbor)` (the tagged-CBOR form).
+* 4. If that fails, fall back to interpreting the CBOR as a bare
+*    byte string and constructing the ARID from those bytes via
+*    `ARID::from_data_ref`.
+*
+* The earlier port only accepted the tagged form; this matches Rust
+* by accepting the byte-string fallback too.
+*/
+function parseAridUr(urString) {
+	const trimmed = urString.trim();
+	if (trimmed.length === 0) throw new Error("ARID is required");
+	const ur = _bcts_uniform_resources.UR.fromURString(trimmed);
+	if (ur.urTypeStr() !== "arid") throw new Error(`Expected a ur:arid, found ur:${ur.urTypeStr()}`);
+	const { ARID: ARIDClass } = require("@bcts/components");
+	const cbor = ur.cbor();
+	try {
+		return ARIDClass.fromTaggedCbor(cbor);
+	} catch {
+		const bytes = cbor.asByteString?.();
+		if (bytes === void 0) throw new Error("Invalid ARID payload");
+		return ARIDClass.fromData(bytes);
+	}
+}
+/**
+* Parse an envelope from a UR string.
+*
+* Port of `parse_envelope_ur()` from cmd/dkg/common.rs.
+*/
+function parseEnvelopeUr(urString) {
+	const ur = _bcts_uniform_resources.UR.fromURString(urString.trim());
+	if (ur.urTypeStr() !== "envelope") throw new Error(`Expected ur:envelope, found ur:${ur.urTypeStr()}`);
+	const { Envelope: EnvelopeClass } = require("@bcts/envelope");
+	return EnvelopeClass.fromCbor(ur.cbor());
+}
+/**
+* Resolve the registry owner's XID document.
+*
+* The earlier port called this `resolveSender(registry)`, but its
+* behaviour — "give me the owner" — has nothing in common with Rust's
+* `resolve_sender(registry, input)` (which resolves an arbitrary
+* named sender). This helper is renamed to its actual behaviour;
+* the Rust-equivalent `resolveSender(registry, input)` lives below.
+*/
+function resolveOwnerXidDocument(registry) {
+	const owner = registry.owner();
+	if (!owner) throw new Error("No owner set in registry. Run 'registry owner set' first.");
+	return owner.xidDocument();
+}
+/**
+* Resolve a sender XID document from the registry by UR or pet name.
+*
+* Mirrors Rust `resolve_sender(registry, input)`
+* (`cmd/dkg/common.rs:76-94`):
+*
+* 1. Trim and reject empty input.
+* 2. Try parsing the input as a `ur:xid`. If that succeeds, look it
+*    up via `registry.participant(xid)`; if no record is found,
+*    error with `Sender with XID {ur} not found`.
+* 3. Otherwise look it up by pet name via
+*    `registry.participantByPetName(name)`; if no record is found,
+*    error with `Sender with pet name '{name}' not found`.
+*
+* Note Rust does NOT check the owner here — only the participants
+* map. The earlier inline duplicate in `participant/round1.ts` did
+* an extra owner-check fallback which is removed to match Rust.
+*/
+function resolveSender(registry, input) {
+	const trimmed = input.trim();
+	if (trimmed.length === 0) throw new Error("Sender is required");
+	let xid;
+	try {
+		const { XID: XIDClass } = require("@bcts/components");
+		xid = XIDClass.fromURString(trimmed);
+	} catch {
+		xid = void 0;
+	}
+	if (xid !== void 0) {
+		const record = registry.participant(xid);
+		if (record !== void 0) return record.xidDocument();
+		throw new Error(`Sender with XID ${xid.urString()} not found`);
+	}
+	const result = registry.participantByPetName(trimmed);
+	if (result !== void 0) {
+		const [, record] = result;
+		return record.xidDocument();
+	}
+	throw new Error(`Sender with pet name '${trimmed}' not found`);
+}
+/**
+* Resolve participant identifiers (XID URs or pet names) to records.
+*
+* Port of `resolve_participants()` from cmd/dkg/common.rs lines 29-74.
+*/
+function resolveParticipants(registry, inputs) {
+	const seenArgs = /* @__PURE__ */ new Set();
+	const seenXids = /* @__PURE__ */ new Set();
+	const resolved = [];
+	for (const raw of inputs) {
+		const trimmed = raw.trim();
+		if (trimmed === "") throw new Error("Participant identifier cannot be empty");
+		if (seenArgs.has(trimmed)) throw new Error(`Duplicate participant argument: ${trimmed}`);
+		seenArgs.add(trimmed);
+		let xid;
+		let record;
+		try {
+			const { XID: XIDClass } = require("@bcts/components");
+			xid = XIDClass.fromURString(trimmed);
+			const foundRecord = registry.participant(xid);
+			if (!foundRecord) throw new Error(`Participant with XID ${xid.urString()} not found in registry`);
+			record = foundRecord;
+		} catch {
+			const result = registry.participantByPetName(trimmed);
+			if (!result) throw new Error(`Participant with pet name '${trimmed}' not found`);
+			[xid, record] = result;
+		}
+		const xidUr = xid.urString();
+		if (seenXids.has(xidUr)) throw new Error(`Duplicate participant specified; multiple inputs resolve to ${xidUr}`);
+		seenXids.add(xidUr);
+		resolved.push([xid, record]);
+	}
+	return resolved;
+}
+/**
+* Get display name for sender from registry.
+*
+* Port of `resolve_sender_name()` from cmd/dkg/common.rs lines 96-116.
+*/
+function resolveSenderName(registry, sender) {
+	const owner = registry.owner();
+	const senderXid = sender.xid();
+	if (owner?.xidDocument().xid().urString() === senderXid.urString()) return formatNameWithOwnerMarker(owner.petName() ?? senderXid.urString(), true);
+	const record = registry.participant(senderXid);
+	if (record) return formatNameWithOwnerMarker(record.petName() ?? record.xid().urString(), false);
+}
+/**
+* Build GroupParticipant[] from XIDDocuments using registry lookups.
+*
+* Port of `build_group_participants()` from cmd/dkg/common.rs lines 122-131.
+*/
+function buildGroupParticipants(registry, owner, participants) {
+	return participants.map((doc) => groupParticipantFromRegistry(registry, owner, doc));
+}
+/**
+* Create a GroupParticipant from a XIDDocument, validating against the registry.
+*
+* Port of `group_participant_from_registry()` from cmd/dkg/common.rs lines 133-149.
+*/
+function groupParticipantFromRegistry(registry, owner, document) {
+	const xid = document.xid();
+	if (xid.urString() === owner.xid().urString()) return new require_registry_index.GroupParticipant(xid);
+	if (!registry.participant(xid)) throw new Error(`Invite participant not found in registry: ${xid.urString()}`);
+	return new require_registry_index.GroupParticipant(xid);
+}
+/**
+* Format a participant name with owner marker if applicable.
+*
+* Port of `format_name_with_owner_marker()` from cmd/dkg/common.rs lines 155-157.
+*/
+function formatNameWithOwnerMarker(name, isOwner) {
+	return isOwner ? `* ${name}` : name;
+}
+/**
+* Get display names for participants, sorted by XID, with owner marked.
+*
+* Port of `participant_names_from_registry()` from cmd/dkg/common.rs lines 159-191.
+*/
+function participantNamesFromRegistry(registry, participants, ownerXid, ownerPetName) {
+	return [...participants].sort((a, b) => require_proposed_participant.compareXidBytes(a.xid().toData(), b.xid().toData())).map((document) => {
+		const xid = document.xid();
+		const isOwner = xid.urString() === ownerXid.urString();
+		let name;
+		if (isOwner) name = ownerPetName ?? xid.urString();
+		else {
+			const record = registry.participant(xid);
+			if (!record) throw new Error(`Invite participant not found in registry: ${xid.urString()}`);
+			name = record.petName() ?? xid.urString();
+		}
+		return formatNameWithOwnerMarker(name, isOwner);
+	});
+}
+/**
+* Get the DKG state directory for a given registry path and group ID.
+*
+* Port of `dkg_state_dir()` from cmd/dkg/common.rs.
+*/
+function dkgStateDir(registryPath, groupIdHex) {
+	const base = node_path.dirname(registryPath);
+	return node_path.join(base, "group-state", groupIdHex, "dkg");
+}
+/**
+* Convert a verifying key bytes to a SigningPublicKey.
+*
+* Port of `signing_key_from_verifying()` from cmd/dkg/common.rs.
+*/
+function signingKeyFromVerifying(verifyingKeyBytes) {
+	const { SigningPublicKey: SigningPublicKeyClass } = require("@bcts/components");
+	return SigningPublicKeyClass.fromBytes(verifyingKeyBytes);
+}
+//#endregion
+//#region src/cmd/common.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+*
+* Common utilities for commands.
+*
+* Port of `cmd/common.rs` from `frost-hubert-rust`.
+*
+* Rust's `cmd::common` exports four cross-cutting helpers used by
+* both the DKG and signing subcommand trees:
+*
+* - `parse_arid_ur` / `signing_key_from_verifying` — re-exported
+*   here so the TS module layout matches Rust. The implementations
+*   live alongside their other DKG-specific siblings in
+*   `cmd/dkg/common.ts` so callers in either tree can keep using
+*   them; this file just surfaces them at the parallel-to-Rust
+*   import path (`@bcts/frost-hubert/cmd/common`).
+* - `group_state_dir` and the verbose-flag helpers are TS-native here.
+*
+* `OptionalStorageSelector` is intentionally not ported: it's a
+* `clap`-specific argument struct and the TS port surfaces the same
+* effect via the `StorageSelection` string-literal union — see the
+* `parity audit` for context.
+*
+* @module
+*/
+/**
+* Get the group state directory for a given registry path and group ID.
+*
+* Port of `group_state_dir()` from cmd/common.rs.
+*/
+function groupStateDir(registryPath, groupIdHex) {
+	const base = node_path.dirname(registryPath);
+	return node_path.join(base, "group-state", groupIdHex);
+}
+/**
+* Global verbose flag.
+*/
+let verboseFlag = false;
+/**
+* Set the verbose flag.
+*/
+function setVerbose(value) {
+	verboseFlag = value;
+}
+/**
+* Check if verbose mode is enabled.
+*
+* Port of `is_verbose()` from cmd/common.rs.
+*/
+function isVerbose() {
+	return verboseFlag;
+}
+//#endregion
+Object.defineProperty(exports, "buildGroupParticipants", {
+	enumerable: true,
+	get: function() {
+		return buildGroupParticipants;
+	}
+});
+Object.defineProperty(exports, "dkgStateDir", {
+	enumerable: true,
+	get: function() {
+		return dkgStateDir;
+	}
+});
+Object.defineProperty(exports, "formatNameWithOwnerMarker", {
+	enumerable: true,
+	get: function() {
+		return formatNameWithOwnerMarker;
+	}
+});
+Object.defineProperty(exports, "groupParticipantFromRegistry", {
+	enumerable: true,
+	get: function() {
+		return groupParticipantFromRegistry;
+	}
+});
+Object.defineProperty(exports, "groupStateDir", {
+	enumerable: true,
+	get: function() {
+		return groupStateDir;
+	}
+});
+Object.defineProperty(exports, "isVerbose", {
+	enumerable: true,
+	get: function() {
+		return isVerbose;
+	}
+});
+Object.defineProperty(exports, "parseAridUr", {
+	enumerable: true,
+	get: function() {
+		return parseAridUr;
+	}
+});
+Object.defineProperty(exports, "parseEnvelopeUr", {
+	enumerable: true,
+	get: function() {
+		return parseEnvelopeUr;
+	}
+});
+Object.defineProperty(exports, "participantNamesFromRegistry", {
+	enumerable: true,
+	get: function() {
+		return participantNamesFromRegistry;
+	}
+});
+Object.defineProperty(exports, "resolveOwnerXidDocument", {
+	enumerable: true,
+	get: function() {
+		return resolveOwnerXidDocument;
+	}
+});
+Object.defineProperty(exports, "resolveParticipants", {
+	enumerable: true,
+	get: function() {
+		return resolveParticipants;
+	}
+});
+Object.defineProperty(exports, "resolveSender", {
+	enumerable: true,
+	get: function() {
+		return resolveSender;
+	}
+});
+Object.defineProperty(exports, "resolveSenderName", {
+	enumerable: true,
+	get: function() {
+		return resolveSenderName;
+	}
+});
+Object.defineProperty(exports, "setVerbose", {
+	enumerable: true,
+	get: function() {
+		return setVerbose;
+	}
+});
+Object.defineProperty(exports, "signingKeyFromVerifying", {
+	enumerable: true,
+	get: function() {
+		return signingKeyFromVerifying;
+	}
+});
+
+//# sourceMappingURL=common-lKP5EzHy.cjs.map

package/dist/common-lKP5EzHy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-lKP5EzHy.cjs","names":["UR","GroupParticipant","compareXidBytes","path","path"],"sources":["../src/cmd/dkg/common.ts","../src/cmd/common.ts"],"sourcesContent":["/**\n * Copyright © 2023-2026 Blockchain Commons, LLC\n * Copyright © 2025-2026 Parity Technologies\n *\n *\n * Common utilities for DKG commands.\n *\n * Port of cmd/dkg/common.rs from frost-hubert-rust.\n *\n * @module\n */\n\nimport * as path from \"node:path\";\n\nimport { type ARID, type XID } from \"@bcts/components\";\nimport { compareXidBytes } from \"../../dkg/proposed-participant.js\";\nimport { type Envelope } from \"@bcts/envelope\";\nimport { UR } from \"@bcts/uniform-resources\";\nimport { type XIDDocument } from \"@bcts/xid\";\n\nimport {\n  GroupParticipant,\n  type OwnerRecord,\n  type ParticipantRecord,\n  type Registry,\n} from \"../../registry/index.js\";\n\n// Re-export cross-cutting utilities for convenience\nexport { groupStateDir } from \"../common.js\";\n\n/**\n * Parse an ARID from a UR string.\n *\n * Mirrors Rust `parse_arid_ur` (`cmd/common.rs:27-43`):\n *\n * 1. Trim and reject empty input.\n * 2. Parse as a UR; require `ur_type` of `\"arid\"`.\n * 3. Try `ARID::try_from(cbor)` (the tagged-CBOR form).\n * 4. If that fails, fall back to interpreting the CBOR as a bare\n *    byte string and constructing the ARID from those bytes via\n *    `ARID::from_data_ref`.\n *\n * The earlier port only accepted the tagged form; this matches Rust\n * by accepting the byte-string fallback too.\n */\nexport function parseAridUr(urString: string): ARID {\n  const trimmed = urString.trim();\n  if (trimmed.length === 0) {\n    throw new Error(\"ARID is required\");\n  }\n  const ur = UR.fromURString(trimmed);\n\n  if (ur.urTypeStr() !== \"arid\") {\n    throw new Error(`Expected a ur:arid, found ur:${ur.urTypeStr()}`);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-require-imports, no-undef\n  const { ARID: ARIDClass } = require(\"@bcts/components\");\n  const cbor = ur.cbor();\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access\n    return ARIDClass.fromTaggedCbor(cbor);\n  } catch {\n    // Fall back to a bare byte string payload, mirroring Rust's\n    // `CBOR::try_into_byte_string(cbor) → ARID::from_data_ref(bytes)`.\n    const bytes = (cbor as { asByteString(): Uint8Array | undefined }).asByteString?.();\n    if (bytes === undefined) {\n      throw new Error(\"Invalid ARID payload\");\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access\n    return ARIDClass.fromData(bytes);\n  }\n}\n\n/**\n * Parse an envelope from a UR string.\n *\n * Port of `parse_envelope_ur()` from cmd/dkg/common.rs.\n */\nexport function parseEnvelopeUr(urString: string): Envelope {\n  const ur = UR.fromURString(urString.trim());\n\n  if (ur.urTypeStr() !== \"envelope\") {\n    throw new Error(`Expected ur:envelope, found ur:${ur.urTypeStr()}`);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-require-imports, no-undef\n  const { Envelope: EnvelopeClass } = require(\"@bcts/envelope\");\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access\n  return EnvelopeClass.fromCbor(ur.cbor());\n}\n\n/**\n * Resolve the registry owner's XID document.\n *\n * The earlier port called this `resolveSender(registry)`, but its\n * behaviour — \"give me the owner\" — has nothing in common with Rust's\n * `resolve_sender(registry, input)` (which resolves an arbitrary\n * named sender). This helper is renamed to its actual behaviour;\n * the Rust-equivalent `resolveSender(registry, input)` lives below.\n */\nexport function resolveOwnerXidDocument(registry: Registry): XIDDocument {\n  const owner = registry.owner();\n\n  if (!owner) {\n    throw new Error(\"No owner set in registry. Run 'registry owner set' first.\");\n  }\n\n  return owner.xidDocument();\n}\n\n/**\n * Resolve a sender XID document from the registry by UR or pet name.\n *\n * Mirrors Rust `resolve_sender(registry, input)`\n * (`cmd/dkg/common.rs:76-94`):\n *\n * 1. Trim and reject empty input.\n * 2. Try parsing the input as a `ur:xid`. If that succeeds, look it\n *    up via `registry.participant(xid)`; if no record is found,\n *    error with `Sender with XID {ur} not found`.\n * 3. Otherwise look it up by pet name via\n *    `registry.participantByPetName(name)`; if no record is found,\n *    error with `Sender with pet name '{name}' not found`.\n *\n * Note Rust does NOT check the owner here — only the participants\n * map. The earlier inline duplicate in `participant/round1.ts` did\n * an extra owner-check fallback which is removed to match Rust.\n */\nexport function resolveSender(registry: Registry, input: string): XIDDocument {\n  const trimmed = input.trim();\n  if (trimmed.length === 0) {\n    throw new Error(\"Sender is required\");\n  }\n\n  // Try parsing as an XID UR string first. `XID.fromURString` throws\n  // when the input isn't a `ur:xid`; that's the signal to fall back\n  // to pet-name lookup.\n  let xid: XID | undefined;\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-require-imports, no-undef\n    const { XID: XIDClass } = require(\"@bcts/components\");\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access\n    xid = XIDClass.fromURString(trimmed) as XID;\n  } catch {\n    xid = undefined;\n  }\n\n  if (xid !== undefined) {\n    const record = registry.participant(xid);\n    if (record !== undefined) {\n      return record.xidDocument();\n    }\n    throw new Error(`Sender with XID ${xid.urString()} not found`);\n  }\n\n  const result = registry.participantByPetName(trimmed);\n  if (result !== undefined) {\n    const [, record] = result;\n    return record.xidDocument();\n  }\n  throw new Error(`Sender with pet name '${trimmed}' not found`);\n}\n\n// -----------------------------------------------------------------------------\n// Participant resolution\n// -----------------------------------------------------------------------------\n\n/**\n * Resolve participant identifiers (XID URs or pet names) to records.\n *\n * Port of `resolve_participants()` from cmd/dkg/common.rs lines 29-74.\n */\nexport function resolveParticipants(\n  registry: Registry,\n  inputs: string[],\n): [XID, ParticipantRecord][] {\n  const seenArgs = new Set<string>();\n  const seenXids = new Set<string>();\n  const resolved: [XID, ParticipantRecord][] = [];\n\n  for (const raw of inputs) {\n    const trimmed = raw.trim();\n    if (trimmed === \"\") {\n      throw new Error(\"Participant identifier cannot be empty\");\n    }\n    if (seenArgs.has(trimmed)) {\n      throw new Error(`Duplicate participant argument: ${trimmed}`);\n    }\n    seenArgs.add(trimmed);\n\n    let xid: XID;\n    let record: ParticipantRecord;\n\n    // Try parsing as XID UR first\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-require-imports, no-undef\n      const { XID: XIDClass } = require(\"@bcts/components\");\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access\n      xid = XIDClass.fromURString(trimmed) as XID;\n\n      const foundRecord = registry.participant(xid);\n      if (!foundRecord) {\n        throw new Error(`Participant with XID ${xid.urString()} not found in registry`);\n      }\n      record = foundRecord;\n    } catch {\n      // Try looking up by pet name\n      const result = registry.participantByPetName(trimmed);\n      if (!result) {\n        throw new Error(`Participant with pet name '${trimmed}' not found`);\n      }\n      [xid, record] = result;\n    }\n\n    const xidUr = xid.urString();\n    if (seenXids.has(xidUr)) {\n      throw new Error(`Duplicate participant specified; multiple inputs resolve to ${xidUr}`);\n    }\n    seenXids.add(xidUr);\n\n    resolved.push([xid, record]);\n  }\n\n  return resolved;\n}\n\n/**\n * Get display name for sender from registry.\n *\n * Port of `resolve_sender_name()` from cmd/dkg/common.rs lines 96-116.\n */\nexport function resolveSenderName(registry: Registry, sender: XIDDocument): string | undefined {\n  const owner = registry.owner();\n  const senderXid = sender.xid();\n\n  // Check if sender is the owner\n  if (owner?.xidDocument().xid().urString() === senderXid.urString()) {\n    const name = owner.petName() ?? senderXid.urString();\n    return formatNameWithOwnerMarker(name, true);\n  }\n\n  // Look up in participants\n  const record = registry.participant(senderXid);\n  if (record) {\n    const name = record.petName() ?? record.xid().urString();\n    return formatNameWithOwnerMarker(name, false);\n  }\n\n  return undefined;\n}\n\n// -----------------------------------------------------------------------------\n// Group participant building\n// -----------------------------------------------------------------------------\n\n/**\n * Build GroupParticipant[] from XIDDocuments using registry lookups.\n *\n * Port of `build_group_participants()` from cmd/dkg/common.rs lines 122-131.\n */\nexport function buildGroupParticipants(\n  registry: Registry,\n  owner: OwnerRecord,\n  participants: XIDDocument[],\n): GroupParticipant[] {\n  return participants.map((doc) => groupParticipantFromRegistry(registry, owner, doc));\n}\n\n/**\n * Create a GroupParticipant from a XIDDocument, validating against the registry.\n *\n * Port of `group_participant_from_registry()` from cmd/dkg/common.rs lines 133-149.\n */\nexport function groupParticipantFromRegistry(\n  registry: Registry,\n  owner: OwnerRecord,\n  document: XIDDocument,\n): GroupParticipant {\n  const xid = document.xid();\n\n  // If the document is the owner, allow it\n  if (xid.urString() === owner.xid().urString()) {\n    return new GroupParticipant(xid);\n  }\n\n  // Otherwise, verify the participant is in the registry\n  if (!registry.participant(xid)) {\n    throw new Error(`Invite participant not found in registry: ${xid.urString()}`);\n  }\n\n  return new GroupParticipant(xid);\n}\n\n// -----------------------------------------------------------------------------\n// Name formatting\n// -----------------------------------------------------------------------------\n\n/**\n * Format a participant name with owner marker if applicable.\n *\n * Port of `format_name_with_owner_marker()` from cmd/dkg/common.rs lines 155-157.\n */\nexport function formatNameWithOwnerMarker(name: string, isOwner: boolean): string {\n  return isOwner ? `* ${name}` : name;\n}\n\n/**\n * Get display names for participants, sorted by XID, with owner marked.\n *\n * Port of `participant_names_from_registry()` from cmd/dkg/common.rs lines 159-191.\n */\nexport function participantNamesFromRegistry(\n  registry: Registry,\n  participants: XIDDocument[],\n  ownerXid: XID,\n  ownerPetName: string | undefined,\n): string[] {\n  // Sort by XID byte order — mirrors Rust `XID::cmp` (raw 32-byte\n  // lex compare). The earlier port used\n  // `urString().localeCompare(...)`, which diverges from byte order\n  // for bytes ≥ 0x80 and is locale-aware.\n  const sorted = [...participants].sort((a, b) =>\n    compareXidBytes(a.xid().toData(), b.xid().toData()),\n  );\n\n  return sorted.map((document) => {\n    const xid = document.xid();\n    const isOwner = xid.urString() === ownerXid.urString();\n\n    let name: string;\n    if (isOwner) {\n      name = ownerPetName ?? xid.urString();\n    } else {\n      const record = registry.participant(xid);\n      if (!record) {\n        throw new Error(`Invite participant not found in registry: ${xid.urString()}`);\n      }\n      name = record.petName() ?? xid.urString();\n    }\n\n    return formatNameWithOwnerMarker(name, isOwner);\n  });\n}\n\n/**\n * Get the DKG state directory for a given registry path and group ID.\n *\n * Port of `dkg_state_dir()` from cmd/dkg/common.rs.\n */\nexport function dkgStateDir(registryPath: string, groupIdHex: string): string {\n  const base = path.dirname(registryPath);\n  return path.join(base, \"group-state\", groupIdHex, \"dkg\");\n}\n\n/**\n * Convert a verifying key bytes to a SigningPublicKey.\n *\n * Port of `signing_key_from_verifying()` from cmd/dkg/common.rs.\n */\nexport function signingKeyFromVerifying(verifyingKeyBytes: Uint8Array): unknown {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-require-imports, no-undef\n  const { SigningPublicKey: SigningPublicKeyClass } = require(\"@bcts/components\");\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access\n  return SigningPublicKeyClass.fromBytes(verifyingKeyBytes);\n}\n","/**\n * Copyright © 2023-2026 Blockchain Commons, LLC\n * Copyright © 2025-2026 Parity Technologies\n *\n *\n * Common utilities for commands.\n *\n * Port of `cmd/common.rs` from `frost-hubert-rust`.\n *\n * Rust's `cmd::common` exports four cross-cutting helpers used by\n * both the DKG and signing subcommand trees:\n *\n * - `parse_arid_ur` / `signing_key_from_verifying` — re-exported\n *   here so the TS module layout matches Rust. The implementations\n *   live alongside their other DKG-specific siblings in\n *   `cmd/dkg/common.ts` so callers in either tree can keep using\n *   them; this file just surfaces them at the parallel-to-Rust\n *   import path (`@bcts/frost-hubert/cmd/common`).\n * - `group_state_dir` and the verbose-flag helpers are TS-native here.\n *\n * `OptionalStorageSelector` is intentionally not ported: it's a\n * `clap`-specific argument struct and the TS port surfaces the same\n * effect via the `StorageSelection` string-literal union — see the\n * `parity audit` for context.\n *\n * @module\n */\n\nimport * as path from \"node:path\";\n\nexport { parseAridUr, signingKeyFromVerifying } from \"./dkg/common.js\";\n\n/**\n * Get the group state directory for a given registry path and group ID.\n *\n * Port of `group_state_dir()` from cmd/common.rs.\n */\nexport function groupStateDir(registryPath: string, groupIdHex: string): string {\n  const base = path.dirname(registryPath);\n  return path.join(base, \"group-state\", groupIdHex);\n}\n\n/**\n * Global verbose flag.\n */\nlet verboseFlag = false;\n\n/**\n * Set the verbose flag.\n */\nexport function setVerbose(value: boolean): void {\n  verboseFlag = value;\n}\n\n/**\n * Check if verbose mode is enabled.\n *\n * Port of `is_verbose()` from cmd/common.rs.\n */\nexport function isVerbose(): boolean {\n  return verboseFlag;\n}\n"],"mappings":"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"}

package/dist/common-lThIvJmZ.cjs

@@ -0,0 +1,114 @@
+require("./chunk-CZWwpsFl.cjs");
+const require_common = require("./common-lKP5EzHy.cjs");
+let _bcts_envelope = require("@bcts/envelope");
+//#region src/cmd/sign/common.ts
+/**
+* Copyright © 2023-2026 Blockchain Commons, LLC
+* Copyright © 2025-2026 Parity Technologies
+*
+*
+* Common utilities for sign commands.
+*
+* Port of cmd/sign/common.rs from frost-hubert-rust.
+*
+* @module
+*/
+/**
+* Get the signing state directory for a group (without session).
+*
+* Path: `{registry_dir}/group-state/{group_id.hex()}/signing`
+*
+* Port of `signing_state_dir_for_group()` from cmd/sign/common.rs.
+*/
+function signingStateDirForGroup(registryPath, groupIdHex) {
+	return `${require_common.groupStateDir(registryPath, groupIdHex)}/signing`;
+}
+/**
+* Get the signing state directory for a given registry path, group ID, and session ID.
+*
+* Path: `{registry_dir}/group-state/{group_id.hex()}/signing/{session_id.hex()}`
+*
+* Port of `signing_state_dir()` from cmd/sign/common.rs.
+*/
+function signingStateDir(registryPath, groupIdHex, sessionIdHex) {
+	return `${signingStateDirForGroup(registryPath, groupIdHex)}/${sessionIdHex}`;
+}
+/**
+* Content wrapper for signFinalize events.
+*
+* This wraps an envelope with a unit subject and type assertion
+* "signFinalize", implementing the traits required by SealedEvent<T>.
+*
+* Port of `struct SignFinalizeContent` from cmd/sign/common.rs.
+*/
+var SignFinalizeContent = class SignFinalizeContent {
+	_envelope;
+	constructor(envelope) {
+		this._envelope = envelope;
+	}
+	/**
+	* Creates a new SignFinalizeContent with a unit subject and type assertion.
+	*
+	* Port of `SignFinalizeContent::new()` from cmd/sign/common.rs.
+	*/
+	static new() {
+		return new SignFinalizeContent(_bcts_envelope.Envelope.unit().addType("signFinalize"));
+	}
+	/**
+	* Adds an assertion to the content envelope.
+	*
+	* Port of `SignFinalizeContent::add_assertion()` from cmd/sign/common.rs.
+	*/
+	addAssertion(predicate, object) {
+		return new SignFinalizeContent(this._envelope.addAssertion(predicate, object));
+	}
+	/**
+	* Returns the inner envelope.
+	*
+	* Port of `SignFinalizeContent::envelope()` from cmd/sign/common.rs.
+	*/
+	envelope() {
+		return this._envelope;
+	}
+	/**
+	* Creates a SignFinalizeContent from an envelope with validation.
+	*
+	* Validates that the envelope has a unit subject and type "signFinalize".
+	*
+	* Port of `TryFrom<Envelope> for SignFinalizeContent` from cmd/sign/common.rs.
+	*/
+	static fromEnvelope(envelope) {
+		envelope.checkSubjectUnit();
+		envelope.checkType("signFinalize");
+		return new SignFinalizeContent(envelope);
+	}
+	/**
+	* Converts this SignFinalizeContent to an Envelope.
+	*
+	* Port of `From<SignFinalizeContent> for Envelope` from cmd/sign/common.rs.
+	*/
+	toEnvelope() {
+		return this._envelope;
+	}
+};
+//#endregion
+Object.defineProperty(exports, "SignFinalizeContent", {
+	enumerable: true,
+	get: function() {
+		return SignFinalizeContent;
+	}
+});
+Object.defineProperty(exports, "signingStateDir", {
+	enumerable: true,
+	get: function() {
+		return signingStateDir;
+	}
+});
+Object.defineProperty(exports, "signingStateDirForGroup", {
+	enumerable: true,
+	get: function() {
+		return signingStateDirForGroup;
+	}
+});
+
+//# sourceMappingURL=common-lThIvJmZ.cjs.map

package/dist/common-lThIvJmZ.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-lThIvJmZ.cjs","names":["groupStateDir","Envelope"],"sources":["../src/cmd/sign/common.ts"],"sourcesContent":["/**\n * Copyright © 2023-2026 Blockchain Commons, LLC\n * Copyright © 2025-2026 Parity Technologies\n *\n *\n * Common utilities for sign commands.\n *\n * Port of cmd/sign/common.rs from frost-hubert-rust.\n *\n * @module\n */\n\nimport { Envelope, type EnvelopeEncodableValue } from \"@bcts/envelope\";\n\nimport { groupStateDir } from \"../common\";\n\n/**\n * Get the signing state directory for a group (without session).\n *\n * Path: `{registry_dir}/group-state/{group_id.hex()}/signing`\n *\n * Port of `signing_state_dir_for_group()` from cmd/sign/common.rs.\n */\nexport function signingStateDirForGroup(registryPath: string, groupIdHex: string): string {\n  return `${groupStateDir(registryPath, groupIdHex)}/signing`;\n}\n\n/**\n * Get the signing state directory for a given registry path, group ID, and session ID.\n *\n * Path: `{registry_dir}/group-state/{group_id.hex()}/signing/{session_id.hex()}`\n *\n * Port of `signing_state_dir()` from cmd/sign/common.rs.\n */\nexport function signingStateDir(\n  registryPath: string,\n  groupIdHex: string,\n  sessionIdHex: string,\n): string {\n  return `${signingStateDirForGroup(registryPath, groupIdHex)}/${sessionIdHex}`;\n}\n\n/**\n * Content wrapper for signFinalize events.\n *\n * This wraps an envelope with a unit subject and type assertion\n * \"signFinalize\", implementing the traits required by SealedEvent<T>.\n *\n * Port of `struct SignFinalizeContent` from cmd/sign/common.rs.\n */\nexport class SignFinalizeContent {\n  private readonly _envelope: Envelope;\n\n  private constructor(envelope: Envelope) {\n    this._envelope = envelope;\n  }\n\n  /**\n   * Creates a new SignFinalizeContent with a unit subject and type assertion.\n   *\n   * Port of `SignFinalizeContent::new()` from cmd/sign/common.rs.\n   */\n  static new(): SignFinalizeContent {\n    const envelope = Envelope.unit().addType(\"signFinalize\");\n    return new SignFinalizeContent(envelope);\n  }\n\n  /**\n   * Adds an assertion to the content envelope.\n   *\n   * Port of `SignFinalizeContent::add_assertion()` from cmd/sign/common.rs.\n   */\n  addAssertion(\n    predicate: EnvelopeEncodableValue,\n    object: EnvelopeEncodableValue,\n  ): SignFinalizeContent {\n    const newEnvelope = this._envelope.addAssertion(predicate, object);\n    return new SignFinalizeContent(newEnvelope);\n  }\n\n  /**\n   * Returns the inner envelope.\n   *\n   * Port of `SignFinalizeContent::envelope()` from cmd/sign/common.rs.\n   */\n  envelope(): Envelope {\n    return this._envelope;\n  }\n\n  /**\n   * Creates a SignFinalizeContent from an envelope with validation.\n   *\n   * Validates that the envelope has a unit subject and type \"signFinalize\".\n   *\n   * Port of `TryFrom<Envelope> for SignFinalizeContent` from cmd/sign/common.rs.\n   */\n  static fromEnvelope(envelope: Envelope): SignFinalizeContent {\n    // Validate it has a unit subject and type \"signFinalize\"\n    envelope.checkSubjectUnit();\n    envelope.checkType(\"signFinalize\");\n    return new SignFinalizeContent(envelope);\n  }\n\n  /**\n   * Converts this SignFinalizeContent to an Envelope.\n   *\n   * Port of `From<SignFinalizeContent> for Envelope` from cmd/sign/common.rs.\n   */\n  toEnvelope(): Envelope {\n    return this._envelope;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,wBAAwB,cAAsB,YAA4B;AACxF,QAAO,GAAGA,eAAAA,cAAc,cAAc,WAAW,CAAC;;;;;;;;;AAUpD,SAAgB,gBACd,cACA,YACA,cACQ;AACR,QAAO,GAAG,wBAAwB,cAAc,WAAW,CAAC,GAAG;;;;;;;;;;AAWjE,IAAa,sBAAb,MAAa,oBAAoB;CAC/B;CAEA,YAAoB,UAAoB;AACtC,OAAK,YAAY;;;;;;;CAQnB,OAAO,MAA2B;AAEhC,SAAO,IAAI,oBADMC,eAAAA,SAAS,MAAM,CAAC,QAAQ,eACF,CAAC;;;;;;;CAQ1C,aACE,WACA,QACqB;AAErB,SAAO,IAAI,oBADS,KAAK,UAAU,aAAa,WAAW,OACjB,CAAC;;;;;;;CAQ7C,WAAqB;AACnB,SAAO,KAAK;;;;;;;;;CAUd,OAAO,aAAa,UAAyC;AAE3D,WAAS,kBAAkB;AAC3B,WAAS,UAAU,eAAe;AAClC,SAAO,IAAI,oBAAoB,SAAS;;;;;;;CAQ1C,aAAuB;AACrB,SAAO,KAAK"}