keri-ts 2.1.0 → 2.2.1

package/esm/keri/npm/src/cli/messaging/multisig.js

@@ -1,30 +1,63 @@
-import { action, spawn } from "effection";
-import { resealRegistryRoots, } from "../../app/credentials/root-replicating.js";
-import { resolveDelegationCommunicationHab } from "../../app/identity/delegating.js";
-import { endpointRoleAccepted, groupSigningMembers, isLocalGroupHab, localGroupMember, proposeGroupEndpointRole, } from "../../app/identity/endpoint-roleing.js";
-import { uniqueMembers } from "../../app/multisig/group-members.js";
-import { MULTISIG_ICP_ROUTE, MULTISIG_IXN_ROUTE, MULTISIG_REV_ROUTE, MULTISIG_ROT_ROUTE, MULTISIG_VCP_ROUTE, } from "../../app/multisig/grouping.js";
-import { approvePendingMultisigProposal, commitAcceptedGroupMembers, eventAccepted, publishProposal, routeForKelEvent, } from "../../app/multisig/multisig-workflows.js";
-import { runAgentRuntime } from "../../app/runtime/agent-runtime.js";
-import { Receiptor, WitnessReceiptor } from "../../app/witness/receipting.js";
+/**
+ * `tufa multisig ...` command implementation.
+ *
+ * The command surface follows KLI's group lifecycle model and calls the library's
+ * proposal API; a command only parses, resolves the user's choices, waits on the
+ * Counselor under runtime workers and returns what to print:
+ * - `incept`, `rotate`, and `interact` propose a group KEL event (`proposeGroup*`)
+ *   and publish a `/multisig/*` EXN to the other members
+ * - `join` approves one stored proposal the user consents to
+ *   (`approveGroupProposal`) and signs nothing else; see `group-join.ts`
+ */
+import { Ilks } from "cesr-ts";
+import { action } from "effection";
+import { registryEventRef, registryEventStatus, settleRegistryEvent } from "../../app/credentials/registry-settling.js";
+import { telEventStatus, waitForIssuedCredential, waitForTelEvent, } from "../../app/credentials/tel-completion.js";
+import { endpointRoleAccepted, isLocalGroupHab, localGroupMember, proposeGroupEndpointRole, } from "../../app/identity/endpoint-roleing.js";
+import { MULTISIG_REV_ROUTE, MULTISIG_ROT_ROUTE, MULTISIG_VCP_ROUTE } from "../../app/multisig/grouping.js";
+import { routeForKelEvent } from "../../app/multisig/multisig-workflows.js";
+import { proposeGroupInception, proposeGroupInteraction, proposeGroupRotation, settleProposedRotation, } from "../../app/multisig/proposing.js";
+import { observeUntil } from "../../app/runtime/workflow-contract.js";
 import { ValidationError } from "../../core/errors.js";
 import { isV2RegistryRoute } from "../../core/exchange/protocol-exchanging.js";
 import { Roles } from "../../core/roles.js";
 import { withAgentRuntime } from "../common/context.js";
 import { loadOptionObject, loadRotateFileOptions, parseBooleanOption, parseCountOption, parseDataItems, parseFileData, parseKeriVersionOption, parseNumberOption, parseStringListOption, parseStringOption, parseThresholdOption, } from "../common/parsing.js";
-import { waitForIssuedCredential, waitForTelPublication } from "../common/tel-completion.js";
-import { resolveWitnessAuths } from "../common/witness-auth.js";
-const MULTISIG_TOPIC = "multisig";
+import { withRuntimeWorkers } from "../common/runtime-workers.js";
+import { joinProposal } from "./group-join.js";
+import { counselInputs, finishAcceptedEvent, supplyDelegationProxy, supplyWitnessAuths, waitForAcceptance, } from "./group-wait.js";
+import { rootCopyLine } from "./root-copy-lines.js";
 /**
  * Re-seal held registry roots to members an accepted group rotation added or
  * rekeyed, as KERIpy `kli multisig rotate|join`. Runs while the command's
  * runtime worker delivers; every outcome is returned, none fails the rotation.
  */
-function* resealAfterRotation(hby, runtime, group, rotation) {
-    const ghab = hby.habs.get(group), root = runtime.registryRoot;
-    if (!ghab || !root)
+function* resealAfterRotation(hby, runtime, group, rotation, since) {
+    const replicating = runtime.rootReplicator, root = runtime.registryRoot;
+    if (!hby.habs.get(group) || !replicating || !root)
         return [];
-    return yield* resealRegistryRoots(root, runtime.postman, runtime.clock, ghab, rotation);
+    replicating.prompt(group);
+    const results = yield* replicating.processOnce();
+    const lines = results.map(rootCopyLine);
+    // The runtime's loop may have sent a copy since the rotation cue prompted it, before this pass: such a copy reads
+    // from the sent marker as transmitted, so the report does not depend on which of the two sent first.
+    const attempted = new Set(results.filter(result => result.group === group).map(result => `${result.registry}/${result.recipient}`));
+    const sender = localGroupMember(hby, group).pre, from = new Date(since).toISOString();
+    for (const [[, registry, recipient], marker] of [...hby.db.rrsn.getTopItemIter([group])]) {
+        if (attempted.has(`${registry}/${recipient}`) || marker.dt < from)
+            continue;
+        if (marker.key !== root.contributor(group, recipient))
+            continue;
+        lines.push({
+            phase: "root_copy",
+            gid: group,
+            registry: registry,
+            sender,
+            recipient: recipient,
+            transmitted: true,
+        });
+    }
+    return lines;
 }
 function requireText(value, label) {
     if (!value) {
@@ -76,8 +109,9 @@ export function* multisigInceptCommand(args) {
         throw new ValidationError("Multisig inception config must include non-empty aids.");
     }
     return yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
-        const member = requireHabByAlias(hby, alias);
-        const created = hby.makeGroupHab(group, member, smids, rmids, undefined, {
+        const sent = yield* proposeGroupInception(proposeDeps(hby, runtime), requireHabByAlias(hby, alias), group, {
+            smids,
+            rmids,
             isith: options.isith,
             nsith: options.nsith,
             toad: options.toad,
@@ -85,33 +119,13 @@ export function* multisigInceptCommand(args) {
             delpre: options.delpre,
             data: options.data ?? [],
             version: commandArgs.version,
-        });
-        const { deliveries, messages } = yield* publishProposal(hby, runtime.protocol, runtime.postman, member, uniqueMembers([...smids, ...rmids]), {
-            route: MULTISIG_ICP_ROUTE,
-            attrs: { smids, rmids, ...(options.delpre ? { delegator: options.delpre } : {}) },
-        }, created.message);
-        const accepted = yield* waitForGroupAcceptance(hby, runtime, created.serder, multisigApprovalOptions(hby, {
-            ...commandArgs,
-            group,
-            auto: true,
-        }));
-        let delegationPhase = null;
-        if (accepted) {
-            yield* receiptAcceptedEvent(hby, created.hab.pre, commandArgs, runtime);
-            delegationPhase = yield* completeDelegationIfNeeded(hby, runtime, created.hab.pre, commandArgs.proxy);
-        }
-        return {
-            route: MULTISIG_ICP_ROUTE,
-            group: created.hab.pre,
-            accepted,
-            messages,
-            deliveries,
-            state: hby.db.getState(created.hab.pre),
-            delegationPhase: delegationPhase,
-        };
+        }, counselInputs(hby, commandArgs.proxy, options.delpre !== undefined, group));
+        const accepted = yield* waitForAcceptance(hby, runtime, sent.event, approvalDeadline(commandArgs));
+        const delegationPhase = accepted ? yield* finishAcceptedEvent(hby, runtime, sent.event, commandArgs) : null;
+        return { ...groupEventResult(hby, sent, accepted), delegationPhase };
     });
 }
-/** Poll for and approve one pending group multisig event. */
+/** Approve one stored group multisig proposal the user consents to. */
 export function* multisigJoinCommand(args) {
     const commandArgs = {
         name: parseStringOption(args.name, "name"),
@@ -128,58 +142,56 @@ export function* multisigJoinCommand(args) {
         auto: parseBooleanOption(args.auto, "auto"),
         registryName: parseStringOption(args.registryName, "registryName"),
         said: parseStringOption(args.said, "said"),
+        kind: parseStringOption(args.kind, "kind"),
         approvalTimeoutSeconds: nonNegativeNumber(args.approvalTimeoutSeconds, 60, "approval timeout seconds"),
         proxy: parseStringOption(args.proxy, "proxy"),
     };
     const name = requireText(commandArgs.name, "Name");
     return yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
-        const approval = multisigApprovalOptions(hby, commandArgs);
-        const result = yield* waitForOneApproval(hby, runtime, approval);
-        if (!result) {
-            const local = yield* waitForLocalGroupCompletion(hby, runtime, approval);
+        const since = runtime.clock.now();
+        const deadline = approvalDeadline(commandArgs);
+        const joined = yield* joinProposal(approvalDeps(hby, runtime), {
+            group: commandArgs.group,
+            said: commandArgs.said,
+            kind: commandArgs.kind,
+            deadline,
+            confirm: proposal => approvePrompt(commandArgs, proposal),
+            groupAlias: proposal => chooseGroupAlias(hby, commandArgs, proposal.group),
+            registryName: proposal => chooseRegistryName(commandArgs, proposal.embedded),
+            inputs: () => ({ fallbackAfterMs: 0 }),
+        });
+        if (!joined) {
+            const local = yield* completeLocalGroupEvent(hby, runtime, commandArgs, deadline, since);
             if (!local) {
                 throw new ValidationError("No matching stored multisig proposal was available to join.");
             }
-            if (local.accepted) {
-                yield* receiptAcceptedEvent(hby, local.group, commandArgs, runtime);
-                if (local.route === MULTISIG_ICP_ROUTE || local.route === MULTISIG_ROT_ROUTE) {
-                    yield* completeDelegationIfNeeded(hby, runtime, local.group, commandArgs.proxy);
-                }
-                if (local.route === MULTISIG_ROT_ROUTE) {
-                    return { ...local, rootCopies: yield* resealAfterRotation(hby, runtime, local.group, local.embedded) };
-                }
-            }
             return local;
         }
+        const { event, ...result } = joined.result;
         if (result.tel) {
             const { publication, reger } = runtime.vdr;
             const tel = result.tel;
             if (result.route === MULTISIG_VCP_ROUTE || result.route === MULTISIG_REV_ROUTE) {
-                yield* waitForTelPublication(publication, tel.pre, tel.sn, approval.deadline);
+                yield* waitForTelEvent({ publication }, tel.pre, tel.sn, { deadline });
                 result.accepted = reger.tels.getOn(tel.pre, tel.sn)?.qb64 === result.embedded;
             }
             else {
-                yield* waitForIssuedCredential(publication, tel.pre, approval.deadline);
+                yield* waitForIssuedCredential({ publication }, tel.pre, { deadline });
                 result.accepted = reger.saved.get(tel.pre) !== null;
             }
-            tel.publicationComplete = publication.complete(tel.pre, tel.sn);
+            tel.publicationComplete = telEventStatus({ publication }, tel.pre, tel.sn).state === "complete";
             return result;
         }
         if (isV2RegistryRoute(result.route)) {
-            result.accepted = yield* settleRegistryApproval(hby, runtime, result, commandArgs, approval.deadline);
+            supplyWitnessAuths(hby, runtime, event, commandArgs);
+            result.accepted = yield* settleRegistryApproval(hby, runtime, result, deadline);
             return result;
         }
-        if (result.accepted) {
-            yield* receiptAcceptedEvent(hby, result.group, commandArgs, runtime);
-            if (result.route === MULTISIG_ICP_ROUTE
-                || result.route === MULTISIG_ROT_ROUTE) {
-                yield* completeDelegationIfNeeded(hby, runtime, result.group, commandArgs.proxy);
-            }
-            if (result.route === MULTISIG_ROT_ROUTE) {
-                return { ...result, rootCopies: yield* resealAfterRotation(hby, runtime, result.group, result.embedded) };
-            }
-        }
-        return result;
+        if (!event)
+            return result;
+        // No scheduling point separates the approval from here, so the Counselor has not yet used its defaults.
+        supplyDelegationProxy(hby, runtime, event, commandArgs.proxy);
+        return yield* finishJoinedEvent(hby, runtime, result, event, commandArgs, since);
     });
 }
 /** Create or begin one group interaction event. */
@@ -204,26 +216,11 @@ export function* multisigInteractCommand(args) {
     const group = requireText(commandArgs.group ?? commandArgs.alias, "Group");
     const data = parseDataItems(commandArgs.data);
     return yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
-        const created = hby.interactGroupHab(group, undefined, { data, version: commandArgs.version });
-        const smids = groupSigningMembers(hby, created.hab.pre);
-        const { deliveries, messages } = yield* publishProposal(hby, runtime.protocol, runtime.postman, localGroupMember(hby, created.hab.pre), smids, { route: MULTISIG_IXN_ROUTE, attrs: { gid: created.hab.pre, smids } }, created.message);
-        const accepted = yield* waitForGroupAcceptance(hby, runtime, created.serder, multisigApprovalOptions(hby, {
-            ...commandArgs,
-            group,
-            auto: true,
-        }));
-        if (accepted) {
-            yield* receiptAcceptedEvent(hby, created.hab.pre, commandArgs, runtime);
-        }
-        return {
-            route: MULTISIG_IXN_ROUTE,
-            group: created.hab.pre,
-            accepted,
-            messages,
-            deliveries,
-            state: hby.db.getState(created.hab.pre),
-            delegationPhase: null,
-        };
+        const sent = yield* proposeGroupInteraction(proposeDeps(hby, runtime), requireGroupHab(hby, group), data, { fallbackAfterMs: 0 }, commandArgs.version);
+        const accepted = yield* waitForAcceptance(hby, runtime, sent.event, approvalDeadline(commandArgs));
+        if (accepted)
+            yield* finishAcceptedEvent(hby, runtime, sent.event, commandArgs);
+        return groupEventResult(hby, sent, accepted);
     });
 }
 /** Rotate or begin rotation of one group identifier. */
@@ -258,7 +255,11 @@ export function* multisigRotateCommand(args) {
     const group = requireText(commandArgs.group ?? commandArgs.alias, "Group");
     const options = mergeRotateOptions(commandArgs);
     return yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
-        const rotated = hby.rotateGroupHab(group, commandArgs.smids, commandArgs.rmids, {
+        const since = runtime.clock.now();
+        const groupHab = requireGroupHab(hby, group);
+        const sent = yield* proposeGroupRotation(proposeDeps(hby, runtime), groupHab, {
+            smids: commandArgs.smids,
+            rmids: commandArgs.rmids,
             isith: options.isith,
             nsith: options.nsith,
             toad: options.toad,
@@ -266,34 +267,17 @@ export function* multisigRotateCommand(args) {
             adds: options.witsAdd,
             data: options.data ?? [],
             version: commandArgs.version,
-        });
-        const smids = commandArgs.smids?.length ? commandArgs.smids : groupSigningMembers(hby, rotated.hab.pre);
-        const rmids = commandArgs.rmids?.length ? commandArgs.rmids : smids;
-        const { deliveries, messages } = yield* publishProposal(hby, runtime.protocol, runtime.postman, localGroupMember(hby, rotated.hab.pre), uniqueMembers([...smids, ...rmids]), { route: MULTISIG_ROT_ROUTE, attrs: { gid: rotated.hab.pre, smids, rmids } }, rotated.message);
-        const accepted = yield* waitForGroupAcceptance(hby, runtime, rotated.serder, multisigApprovalOptions(hby, {
-            ...commandArgs,
-            group,
-            auto: true,
-        }));
+        }, counselInputs(hby, commandArgs.proxy, !!hby.db.getKever(groupHab.pre)?.delpre, group));
+        const accepted = yield* waitForAcceptance(hby, runtime, sent.event, approvalDeadline(commandArgs));
         let delegationPhase = null;
         let rootCopies = [];
         if (accepted) {
             // The proposer's own acceptance must commit the rotated membership as a joiner's does.
-            commitAcceptedGroupMembers(hby, rotated.serder, smids, rmids);
-            yield* receiptAcceptedEvent(hby, rotated.hab.pre, commandArgs, runtime);
-            delegationPhase = yield* completeDelegationIfNeeded(hby, runtime, rotated.hab.pre, commandArgs.proxy);
-            rootCopies = yield* resealAfterRotation(hby, runtime, rotated.hab.pre, rotated.serder.said);
+            settleProposedRotation({ hby }, sent);
+            delegationPhase = yield* finishAcceptedEvent(hby, runtime, sent.event, commandArgs);
+            rootCopies = yield* resealAfterRotation(hby, runtime, sent.group, sent.event.said, since);
         }
-        return {
-            route: MULTISIG_ROT_ROUTE,
-            group: rotated.hab.pre,
-            accepted,
-            messages,
-            deliveries,
-            state: hby.db.getState(rotated.hab.pre),
-            delegationPhase: delegationPhase,
-            rootCopies,
-        };
+        return { ...groupEventResult(hby, sent, accepted), delegationPhase, rootCopies };
     });
 }
 /** Propose one group multisig reply such as `/end/role/add`. */
@@ -318,12 +302,12 @@ export function* multisigRpyCommand(args) {
     return yield* withMultisigRuntime(commandArgs, name, function* ({ hby, runtime }) {
         const groupHab = requireHabByAlias(hby, group);
         const result = yield* proposeGroupEndpointRole(hby, runtime.protocol, runtime.postman, groupHab, { eid, role, allow: commandArgs.allow });
+        // The reply is accepted when the other members' contributions reach this runtime.
         const accepted = commandArgs.approvalTimeoutSeconds > 0
-            ? yield* waitForReplyAcceptance(hby, runtime, groupHab.pre, role, eid, multisigApprovalOptions(hby, {
-                ...commandArgs,
-                group: groupHab.pre,
-                auto: true,
-            }))
+            ? yield* observeUntil(() => endpointRoleAccepted(hby, groupHab.pre, role, eid), {
+                timeoutMs: Math.max(0, approvalDeadline(commandArgs) - Date.now()),
+                pollMs: 250,
+            })
             : result.accepted;
         return { ...result, accepted };
     });
@@ -340,13 +324,7 @@ function* withMultisigRuntime(args, name, use) {
         const signer = selected && isLocalGroupHab(context.hby, selected)
             ? localGroupMember(context.hby, selected.pre)
             : selected;
-        const worker = yield* spawn(() => runAgentRuntime(context.runtime, { hab: signer }));
-        try {
-            return yield* use(context);
-        }
-        finally {
-            yield* worker.halt();
-        }
+        return yield* withRuntimeWorkers(context.runtime, { hab: signer }, () => use(context));
     });
 }
 function requireHabByAlias(hby, alias) {
@@ -356,6 +334,12 @@ function requireHabByAlias(hby, alias) {
     }
     return hab;
 }
+function requireGroupHab(hby, group) {
+    const hab = hby.habByName(group);
+    if (!hab)
+        throw new ValidationError(`Group alias ${group} is invalid.`);
+    return hab;
+}
 function mergeRotateOptions(args) {
     const options = args.file && args.file !== "" ? loadRotateFileOptions(args.file) : {};
     if (args.isith !== undefined) {
@@ -384,23 +368,78 @@ function mergeRotateOptions(args) {
     }
     return options;
 }
-function multisigApprovalOptions(hby, args) {
-    // An existing group constrains approval; a new alias only names the group
-    // after its inception proposal is selected and approved.
+/** Deadline of this command's approval wait, measured from when the wait starts. */
+function approvalDeadline(args) {
+    return Date.now() + args.approvalTimeoutSeconds * 1000;
+}
+function proposeDeps(hby, runtime) {
+    return { hby, protocol: runtime.protocol, postman: runtime.postman, counselor: runtime.counselor };
+}
+function approvalDeps(hby, runtime) {
     return {
-        group: args.group ? groupHabByAliasOrPrefix(hby, args.group)?.pre : undefined,
-        said: args.said,
-        deadline: Date.now() + args.approvalTimeoutSeconds * 1000,
-        callbacks: multisigApprovalCallbacks(hby, args),
+        hby,
+        exc: runtime.exc,
+        reactor: runtime.reactor,
+        protocol: runtime.protocol,
+        postman: runtime.postman,
+        notifier: runtime.notifier,
+        registryStore: runtime.acdc?.store ?? null,
+        vdr: runtime.vdr,
+        counselor: runtime.counselor,
     };
 }
-function multisigApprovalCallbacks(hby, args) {
+function groupEventResult(hby, sent, accepted) {
     return {
-        approveProposal: (context) => approvePrompt(args, context),
-        chooseGroupAlias: (groupPre) => chooseGroupAlias(hby, args, groupPre),
-        chooseRegistryName: (regk) => chooseRegistryName(args, regk),
+        route: sent.route,
+        group: sent.group,
+        accepted,
+        messages: sent.messages,
+        deliveries: sent.deliveries,
+        members: sent.members,
+        state: hby.db.getState(sent.group),
+        delegationPhase: null,
     };
 }
+/**
+ * A joined event that this approval completed has nothing left to wait for from other
+ * members; finish its receipts and delegation. One that still needs other members
+ * returns at once and stays counseled in the store.
+ */
+function* finishJoinedEvent(hby, runtime, result, event, args, since) {
+    if (!result.accepted)
+        return result;
+    yield* finishAcceptedEvent(hby, runtime, event, args);
+    if (result.route !== MULTISIG_ROT_ROUTE)
+        return result;
+    return { ...result, rootCopies: yield* resealAfterRotation(hby, runtime, result.group, result.embedded, since) };
+}
+/** Resume a locally authored group event named by `--group` when no proposal was left to join. */
+function* completeLocalGroupEvent(hby, runtime, args, deadline, since) {
+    if (!args.group || args.said)
+        return null;
+    const groupHab = hby.habByName(args.group) ?? hby.habs.get(args.group);
+    if (!groupHab?.pre || !isLocalGroupHab(hby, groupHab))
+        return null;
+    const serder = hby.db.getKever(groupHab.pre)?.serder ?? hby.db.getEvtSerder(groupHab.pre, groupHab.pre);
+    const route = serder && routeForKelEvent(serder);
+    if (!serder?.said || serder.sn === null || !route)
+        return null;
+    const event = { pre: groupHab.pre, sn: serder.sn, said: serder.said };
+    const delegated = serder.ilk === Ilks.dip || serder.ilk === Ilks.drt;
+    runtime.counselor.start(event, counselInputs(hby, args.proxy, delegated, groupHab.pre));
+    const accepted = yield* waitForAcceptance(hby, runtime, event, deadline);
+    const result = {
+        route,
+        said: "",
+        embedded: serder.said,
+        group: groupHab.pre,
+        accepted,
+        deliveries: [],
+        messages: [],
+        members: [],
+    };
+    return yield* finishJoinedEvent(hby, runtime, result, event, args, since);
+}
 function chooseRegistryName(args, regk) {
     if (args.registryName) {
         return args.registryName;
@@ -439,70 +478,38 @@ function chooseGroupAlias(hby, args, groupPre) {
         return group;
     }
 }
-function approvePrompt(args, context) {
+/** Ask whether to join a proposal; `--auto` answers yes without asking, only for the join command that set it. */
+export function approvePrompt(args, proposal) {
     if (args.auto) {
         return true;
     }
     console.log(JSON.stringify({
-        route: context.route,
-        group: context.group,
-        embedded: context.embedded,
+        route: `/multisig/${proposal.kind}`,
+        group: proposal.group,
+        embedded: proposal.embedded,
     }, null, 2));
     const yn = prompt("\nJoin [Y|n]? ");
     return yn === null || yn === "" || yn === "y" || yn === "Y";
 }
-/**
- * Collect witness receipts for the current accepted multisig event using explicit runtime collaborators.
- *
- * @param hby Borrowed local identities and accepted-state stores.
- * @param pre Accepted group event subject.
- * @param args Witness authentication and HTTP endpoint mode choices.
- * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
- * @param sn Accepted event ordinal to receipt; defaults to the current event.
- */
-function* receiptAcceptedEvent(hby, pre, args, runtime, sn) {
-    const kever = hby.db.getKever(pre);
-    if (!kever || kever.wits.length === 0) {
-        return;
-    }
-    const auths = resolveWitnessAuths(kever.wits, args.code ?? [], {
-        codeTime: args.codeTime,
-        promptMissing: args.authenticate ?? false,
-    });
-    if (args.endpoint) {
-        const receiptor = new Receiptor(hby, runtime.protocol, runtime.http, runtime.clock);
-        yield* receiptor.receipt(pre, { sn: sn ?? kever.sn, auths });
-    }
-    else {
-        const witDoer = new WitnessReceiptor(hby, runtime.protocol, runtime.http, runtime.clock);
-        yield* witDoer.submit(pre, { sn: sn ?? kever.sn, auths });
-    }
-}
 /**
  * Settle one approved v2 RIP/BUP as KERIpy's join Counselor does: wait for the group's KEL acceptance of
- * the exact anchor, converge that anchor's witness receipts, and let the anchor escrow accept the TEL event.
- * The TEL event needs a fully witnessed anchor, so receipting only after TEL acceptance would never accept it.
+ * the exact anchor and let the anchor escrow accept the TEL event. The Counselor, started by the approval,
+ * converges the anchor's witness receipts, which the TEL event needs.
  *
  * @returns Whether the approved TEL event is accepted before the approval deadline.
  */
-function* settleRegistryApproval(hby, runtime, result, args, deadline) {
+function* settleRegistryApproval(hby, runtime, result, deadline) {
     const store = runtime.acdc?.store, tel = store?.event(result.embedded);
     const anc = hby.db.exns.get([result.said])?.sad?.a?.anc;
     if (!store || !tel || typeof tel.sad?.n !== "string" || typeof anc !== "string")
         return result.accepted;
-    const regid = tel.ilk === "rip" ? tel.said : tel.regid, sn = Number(BigInt(`0x${tel.sad.n}`));
-    let receipted = false;
+    const anchor = hby.db.getEvtSerder(result.group, anc);
+    const ref = registryEventRef(tel, { pre: result.group, sn: anchor?.sn ?? 0, said: anc });
+    const deps = { db: hby.db, store, protocol: runtime.protocol };
     while (true) {
-        if (store.seqEvent(regid, sn)?.said === tel.said)
+        if (registryEventStatus(deps, ref).state === "accepted")
             return true;
-        const anchor = hby.db.getEvtSerder(result.group, anc);
-        if (!receipted && anchor && hby.db.kels.getLast(result.group, anchor.sn) === anc) {
-            if (!hby.db.fullyWitnessed(anchor))
-                yield* receiptAcceptedEvent(hby, result.group, args, runtime, anchor.sn);
-            receipted = true;
-        }
-        yield* runtime.protocol.processEscrowsOnce();
-        if (store.seqEvent(regid, sn)?.said === tel.said)
+        if ((yield* settleRegistryEvent(deps, ref)).state === "accepted")
             return true;
         if (Date.now() >= deadline)
             return false;
@@ -517,108 +524,6 @@ function nonNegativeNumber(value, fallback, label) {
     }
     return parsed;
 }
-/** Approve stored proposals until the target event is accepted or the deadline expires. */
-function* waitForGroupAcceptance(hby, runtime, serder, options) {
-    if (eventAccepted(hby, serder)) {
-        return true;
-    }
-    while (true) {
-        yield* approvePendingMultisigProposal(hby, runtime, options);
-        if (eventAccepted(hby, serder)) {
-            return true;
-        }
-        if (Date.now() >= options.deadline)
-            break;
-        yield* sleep(Math.min(250, options.deadline - Date.now()));
-    }
-    return eventAccepted(hby, serder);
-}
-/** Wait for one stored proposal while the command host owns background progress. */
-function* waitForOneApproval(hby, runtime, options) {
-    while (true) {
-        const result = yield* approvePendingMultisigProposal(hby, runtime, options);
-        if (result) {
-            return result;
-        }
-        if (Date.now() >= options.deadline)
-            break;
-        yield* sleep(Math.min(250, options.deadline - Date.now()));
-    }
-    return null;
-}
-/** Wait for a locally authored group event to complete through stored approvals. */
-function* waitForLocalGroupCompletion(hby, runtime, options) {
-    if (!options.group || options.said) {
-        return null;
-    }
-    const groupHab = groupHabByAliasOrPrefix(hby, options.group);
-    if (!groupHab?.pre) {
-        return null;
-    }
-    const serder = localGroupJoinSerder(hby, groupHab.pre);
-    if (!serder) {
-        return null;
-    }
-    const route = routeForKelEvent(serder);
-    if (!route) {
-        return null;
-    }
-    const accepted = yield* waitForGroupAcceptance(hby, runtime, serder, options);
-    return {
-        route,
-        said: "",
-        embedded: serder.said ?? "",
-        group: groupHab.pre,
-        accepted,
-        deliveries: [],
-        messages: [],
-    };
-}
-/** Approve stored proposals until the endpoint reply is accepted or the deadline expires. */
-function* waitForReplyAcceptance(hby, runtime, groupPre, role, eid, options) {
-    if (endpointRoleAccepted(hby, groupPre, role, eid)) {
-        return true;
-    }
-    while (true) {
-        yield* approvePendingMultisigProposal(hby, runtime, options);
-        if (endpointRoleAccepted(hby, groupPre, role, eid)) {
-            return true;
-        }
-        if (Date.now() >= options.deadline)
-            break;
-        yield* sleep(Math.min(250, options.deadline - Date.now()));
-    }
-    return endpointRoleAccepted(hby, groupPre, role, eid);
-}
-/** Complete the delegation workflow for an accepted delegated group event. */
-function* completeDelegationIfNeeded(hby, runtime, pre, proxy) {
-    const kever = hby.db.getKever(pre);
-    if (!kever?.delpre) {
-        return null;
-    }
-    const communicationHab = resolveDelegationCommunicationHab(hby, proxy);
-    if (!communicationHab) {
-        throw new ValidationError(`Delegated group event for ${pre} requires --proxy <alias>.`);
-    }
-    runtime.delegating.beginLatest(pre, kever.sn, { communicationHab });
-    const deadline = Date.now() + 120_000;
-    while (!runtime.delegating.complete(pre, kever.sn)) {
-        if (Date.now() >= deadline)
-            throw new Error("Runtime did not converge within 120000ms.");
-        yield* sleep(Math.min(250, deadline - Date.now()));
-    }
-    return runtime.delegating.workflowStatus(pre, kever.sner.numh).phase;
-}
-function groupHabByAliasOrPrefix(hby, group) {
-    return hby.habByName(group) ?? hby.habs.get(group) ?? null;
-}
-function localGroupJoinSerder(hby, groupPre) {
-    const kever = hby.db.getKever(groupPre);
-    if (kever?.serder) {
-        return kever.serder;
-    }
-    return hby.db.getEvtSerder(groupPre, groupPre);
-}
 function* sleep(ms) {
     yield* action((resolve) => {
         const id = setTimeout(resolve, ms);

package/esm/keri/npm/src/cli/messaging/root-copy-lines.js

@@ -0,0 +1,31 @@
+/** The operator command that resends a copy automatic replication did not send. */
+export const RootCopyRecoveryCommand = "tufa vc registry root send";
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Map one typed copy result to its `root_copy` line. */
+export function rootCopyLine(result) {
+    const line = {
+        phase: "root_copy",
+        gid: result.group,
+        registry: result.registry,
+        sender: result.sender,
+        recipient: result.recipient,
+        transmitted: false,
+    };
+    if (result.exchange !== undefined)
+        line.exchange = result.exchange;
+    if (result.kin === "sent")
+        return { ...line, transmitted: true };
+    return { ...line, error: errorText(result.error), recovery: RootCopyRecoveryCommand };
+}
+/** Map an unexaminable rotation to its `root_copy` line. */
+export function rootResealLine(examination) {
+    return {
+        phase: "root_copy",
+        gid: examination.group,
+        rotation: examination.rotation,
+        transmitted: false,
+        error: examination.error.message,
+    };
+}