keri-ts 2.1.0 → 2.2.0

package/esm/keri/npm/src/cli/credentials/ipex.js

@@ -2,9 +2,13 @@ import * as dntShim from "../../_dnt.shims.js";
 import { concatBytes, Counter, parse, SerderKERI } from "cesr-ts";
 import { action, spawn } from "effection";
 import { Organizer } from "../../app/identity/organizing.js";
-import { credentialSaidFromGrant, ipexCredentialAdmit, ipexCredentialGrant, processCredentialPresentationArtifacts, storedGrantArtifacts, validateAdmitGrant, } from "../../app/ipex/ipex-credentialing.js";
+import { approveGroupIpex, waitForGroupIpex } from "../../app/ipex/group-ipex.js";
+import { requireIpexPrior, sendIpexAgree, sendIpexApply, sendIpexOffer, sendIpexSpurn, waitForIpexExchange, } from "../../app/ipex/ipex-conversation.js";
+import { ipexCredentialAdmit, ipexCredentialGrant, } from "../../app/ipex/ipex-credentialing.js";
+import { requireAdmittableGrant, sendIpexAdmit, sendIpexGrant, settleGrantCredential, } from "../../app/ipex/ipex-granting.js";
 import { approveMultisigIpex, approveStoredMultisigIpexWrappers, findPendingMultisigIpex, groupIpexPartial, publishInitialGroupIpex, requireStoredExchange, sendCompletedGroupIpex, sendCredentialStream, storedExchangeMessage, storedMultisigIpexBody, } from "../../app/ipex/ipex-grouping.js";
-import { IPEX_ADMIT_ROUTE, IPEX_AGREE_ROUTE, IPEX_APPLY_ROUTE, IPEX_GRANT_ROUTE, IPEX_OFFER_ROUTE, IPEX_SPURN_ROUTE, validateIpexReply, } from "../../app/ipex/ipexing.js";
+import { IPEX_ADMIT_ROUTE, IPEX_AGREE_ROUTE, IPEX_APPLY_ROUTE, IPEX_GRANT_ROUTE, IPEX_OFFER_ROUTE, IPEX_SPURN_ROUTE, } from "../../app/ipex/ipexing.js";
+import { ipexBaseline, MailboxIntakeTally, settleStoredGrants, waitForIpexArrival, } from "../../app/mailbox/ipex-arrival.js";
 import { isLocalGroupHab, localGroupMember } from "../../app/multisig/group-members.js";
 import { MULTISIG_EXN_ROUTE } from "../../app/multisig/grouping.js";
 import { abortable } from "../../app/runtime/abortable.js";
@@ -14,9 +18,9 @@ import { fileBytes } from "../../app/transport/file-bytes.js";
 import { parseGvrsn } from "../../core/attachment-countering.js";
 import { ValidationError } from "../../core/errors.js";
 import { exchange } from "../../core/exchange/protocol-exchanging.js";
-import { CREDENTIAL_MAILBOX_TOPIC } from "../../core/mailbox/mailbox-topics.js";
 import { withAgentRuntime } from "../common/context.js";
 import { parseBooleanOption, parseNumberOption, parseStringOption } from "../common/parsing.js";
+import { withRuntimeWorkers } from "../common/runtime-workers.js";
 /**
  * Implement `tufa ipex apply` by sending a schema/attribute request EXN.
  *
@@ -31,13 +35,22 @@ export function* ipexApplyCommand(args) {
     return yield* withIpexRuntime(ipexArgs, function* ({ hby, runtime }) {
         const hab = requireHab(hby, ipexArgs.alias);
         const recipient = new Organizer(hby.db, hby.signator).resolveRecipient(requireString(ipexArgs.recipient, "Recipient"));
-        const prepared = exchange(IPEX_APPLY_ROUTE, {
-            m: ipexArgs.message ?? "",
-            s: schema,
-            a: attrs,
-            i: recipient,
-        }, { sender: hab.pre, recipient });
-        return yield* sendConversation(hby, runtime, hab, recipient, prepared, timeout);
+        if (isLocalGroupHab(hby, hab)) {
+            // TODO(group proposal API): replace with the multisig proposal API from app/multisig/counseling.ts.
+            const prepared = exchange(IPEX_APPLY_ROUTE, {
+                m: ipexArgs.message ?? "",
+                s: schema,
+                a: attrs,
+                i: recipient,
+            }, { sender: hab.pre, recipient });
+            return yield* sendGroupConversation(hby, runtime, hab, recipient, prepared, timeout);
+        }
+        return yield* withRuntimeWorkers(runtime, { hab }, () => sendIpexApply(ipexSendDeps(hby, runtime), hab, {
+            recipient,
+            schema: schema,
+            attrs,
+            message: ipexArgs.message,
+        }));
     });
 }
 /**
@@ -54,15 +67,21 @@ export function* ipexOfferCommand(args) {
     return yield* withIpexRuntime(ipexArgs, function* ({ hby, runtime }) {
         const hab = requireHab(hby, ipexArgs.alias);
         const recipient = new Organizer(hby.db, hby.signator).resolveRecipient(requireString(ipexArgs.recipient, "Recipient"));
+        // A bad prior is reported before an unreadable ACDC file.
         if (apply)
-            requireConversationPrior(hby, hab, recipient, apply, "offer");
-        const prepared = exchange(IPEX_OFFER_ROUTE, { m: ipexArgs.message ?? "" }, {
-            sender: hab.pre,
-            recipient,
-            dig: apply,
-            embeds: { acdc: dntShim.Deno.readFileSync(acdcFile) },
-        });
-        return yield* sendConversation(hby, runtime, hab, recipient, prepared, timeout);
+            requireIpexPrior(hby, hab.pre, recipient, apply, "offer");
+        const acdc = dntShim.Deno.readFileSync(acdcFile);
+        if (isLocalGroupHab(hby, hab)) {
+            // TODO(group proposal API): replace with the multisig proposal API from app/multisig/counseling.ts.
+            const prepared = exchange(IPEX_OFFER_ROUTE, { m: ipexArgs.message ?? "" }, {
+                sender: hab.pre,
+                recipient,
+                dig: apply,
+                embeds: { acdc },
+            });
+            return yield* sendGroupConversation(hby, runtime, hab, recipient, prepared, timeout);
+        }
+        return yield* withRuntimeWorkers(runtime, { hab }, () => sendIpexOffer(ipexSendDeps(hby, runtime), hab, { recipient, acdc, apply, message: ipexArgs.message }));
     });
 }
 /** Implement `tufa ipex agree` as a response to an accepted offer EXN. */
@@ -80,13 +99,17 @@ export function* ipexSpurnCommand(args) {
     return yield* withIpexRuntime(ipexArgs, function* ({ hby, runtime }) {
         const hab = requireHab(hby, ipexArgs.alias);
         const dest = new Organizer(hby.db, hby.signator).resolveRecipient(requireString(ipexArgs.recipient, "Recipient"));
-        requireConversationPrior(hby, hab, dest, prior, "spurn");
-        const prepared = exchange(IPEX_SPURN_ROUTE, { m: ipexArgs.message ?? "" }, {
-            sender: hab.pre,
-            recipient: dest,
-            dig: prior,
-        });
-        return yield* sendConversation(hby, runtime, hab, dest, prepared, timeout);
+        if (isLocalGroupHab(hby, hab)) {
+            requireIpexPrior(hby, hab.pre, dest, prior, "spurn");
+            // TODO(group proposal API): replace with the multisig proposal API from app/multisig/counseling.ts.
+            const prepared = exchange(IPEX_SPURN_ROUTE, { m: ipexArgs.message ?? "" }, {
+                sender: hab.pre,
+                recipient: dest,
+                dig: prior,
+            });
+            return yield* sendGroupConversation(hby, runtime, hab, dest, prepared, timeout);
+        }
+        return yield* withRuntimeWorkers(runtime, { hab }, () => sendIpexSpurn(ipexSendDeps(hby, runtime), hab, { recipient: dest, prior, message: ipexArgs.message }));
     });
 }
 /**
@@ -113,9 +136,29 @@ export function* ipexGrantCommand(args) {
         else {
             recipient = new Organizer(hby.db, hby.signator).resolveRecipient(selectedRecipient);
         }
+        if (!isLocalGroupHab(hby, hab)) {
+            return yield* withRuntimeWorkers(runtime, { hab }, function* () {
+                const sent = yield* sendIpexGrant({ ...ipexSendDeps(hby, runtime), reger }, hab, {
+                    recipient,
+                    credential: ipexArgs.said,
+                    message: ipexArgs.message,
+                    agree: ipexArgs.agree,
+                    gvrsn: ipexArgs.gvrsn,
+                    deliver: !ipexArgs.out,
+                });
+                if (ipexArgs.out)
+                    dntShim.Deno.writeFileSync(ipexArgs.out, concatBytes(...sent.support, sent.wire));
+                return {
+                    grant: sent.grant,
+                    credential: ipexArgs.said,
+                    support: sent.support.length,
+                    deliveries: sent.deliveries,
+                };
+            });
+        }
+        // TODO(group proposal API): replace the group branch with the multisig proposal API from app/multisig/counseling.ts.
         if (ipexArgs.agree)
             requireConversationPrior(hby, hab, recipient, ipexArgs.agree, "grant");
-        const group = isLocalGroupHab(hby, hab);
         const grant = ipexCredentialGrant({
             hby,
             hab,
@@ -127,26 +170,14 @@ export function* ipexGrantCommand(args) {
                 agree: ipexArgs.agree ? hby.db.exns.get([ipexArgs.agree]) : null,
                 gvrsn: ipexArgs.gvrsn,
             },
-            sign: !group,
+            sign: false,
         });
         const genus = grant.grant.gvrsn ?? ipexArgs.gvrsn ?? grant.grant.pvrsn;
-        const wire = group ? groupIpexPartial(hby, hab, grant.grant, grant.attachments, genus) : grant.wire;
-        const signer = group ? localGroupMember(hby, hab.pre) : hab;
-        const host = yield* spawn(() => runAgentRuntime(runtime, { hab: signer, pollMailbox: group }));
-        try {
+        const wire = groupIpexPartial(hby, hab, grant.grant, grant.attachments, genus);
+        const signer = localGroupMember(hby, hab.pre);
+        return yield* withRuntimeWorkers(runtime, { hab: signer, pollMailbox: true }, function* () {
             yield* runtime.reactor.processBytes(concatBytes(Counter.makeGVC(genus), wire), { local: true });
             yield* runtime.protocol.processEscrowsOnce();
-            if (!group) {
-                if (!runtime.exc.complete(grant.grant.said))
-                    throw new ValidationError("Local IPEX grant was not accepted.");
-                const deliveries = [];
-                if (!ipexArgs.out) {
-                    deliveries.push(...yield* sendCredentialStream(runtime.postman, hab, recipient, [...grant.support, wire]));
-                }
-                if (ipexArgs.out)
-                    dntShim.Deno.writeFileSync(ipexArgs.out, concatBytes(...grant.support, wire));
-                return { grant: grant.grant, credential: ipexArgs.said, support: grant.support.length, deliveries };
-            }
             const publication = yield* publishInitialGroupIpex(hby, runtime.protocol, runtime.postman, hab, wire, genus);
             const complete = yield* waitForGroupIpexApproval(hby, runtime.protocol, grant.grant.said, ipexArgs.approvalTimeoutSeconds, reger);
             const deliveries = [...publication.deliveries];
@@ -174,10 +205,7 @@ export function* ipexGrantCommand(args) {
                 deliveries,
                 group: { ...publication, complete: true, lead },
             };
-        }
-        finally {
-            yield* host.halt();
-        }
+        });
     });
 }
 /**
@@ -202,18 +230,26 @@ export function* ipexAdmitCommand(args) {
         const selected = yield* loadGrant(hby, ipexArgs);
         const group = isLocalGroupHab(hby, hab);
         const signer = group ? localGroupMember(hby, hab.pre) : hab;
-        const host = yield* spawn(() => runAgentRuntime(runtime, { hab: signer, pollMailbox: group }));
-        try {
+        return yield* withRuntimeWorkers(runtime, { hab: signer, pollMailbox: group }, function* () {
             if (selected.wire)
                 yield* runtime.reactor.processBytes(selected.wire);
-            const grant = requireStoredExchange(hby, selected.grant.said);
-            const recipient = grantSender(grant);
-            requireConversationPrior(hby, hab, recipient, grant.said, "admit");
-            const credential = validateAdmitGrant(grant, hab.pre, reger, false);
+            const { grant, recipient, credential } = requireAdmittableGrant({ hby, reger }, hab, selected.grant.said);
             if (!ipexArgs.noWait
-                && !(yield* settleGrantCredential(hby, runtime.protocol, reger, grant, hab.pre, ipexArgs.gvrsn, ipexArgs.timeout))) {
+                && !(yield* settleAndWaitForCredential(hby, runtime.protocol, reger, grant, hab.pre, ipexArgs.gvrsn, ipexArgs.timeout))) {
                 return { admit: null, grant, credential, saved: false, deliveries: [] };
             }
+            if (!group) {
+                const sent = yield* sendIpexAdmit({ ...ipexSendDeps(hby, runtime), reger }, hab, grant.said, {
+                    message: ipexArgs.message,
+                    gvrsn: ipexArgs.gvrsn,
+                    requireSaved: !ipexArgs.noWait,
+                    deliver: !ipexArgs.out,
+                });
+                if (ipexArgs.out)
+                    dntShim.Deno.writeFileSync(ipexArgs.out, sent.wire);
+                return { admit: sent.admit, grant, credential, saved: sent.saved, deliveries: sent.deliveries };
+            }
+            // TODO(group proposal API): replace the group branch with the multisig proposal API from app/multisig/counseling.ts.
             const saved = !!reger.saved.get([credential]);
             const prepared = ipexCredentialAdmit({
                 hab,
@@ -221,23 +257,13 @@ export function* ipexAdmitCommand(args) {
                 grant,
                 message: ipexArgs.message ?? "",
                 options: { requireSaved: !ipexArgs.noWait, gvrsn: ipexArgs.gvrsn },
-                sign: !group,
+                sign: false,
             });
             const genus = prepared.admit.gvrsn ?? ipexArgs.gvrsn ?? prepared.admit.pvrsn;
-            const wire = group ? groupIpexPartial(hby, hab, prepared.admit, prepared.attachments, genus) : prepared.wire;
+            const wire = groupIpexPartial(hby, hab, prepared.admit, prepared.attachments, genus);
             yield* runtime.reactor.processBytes(concatBytes(Counter.makeGVC(genus), wire), { local: true });
             yield* runtime.protocol.processEscrowsOnce();
             const deliveries = [];
-            if (!group) {
-                if (!runtime.exc.complete(prepared.admit.said)) {
-                    throw new ValidationError("Local IPEX admit was not accepted.");
-                }
-                if (ipexArgs.out)
-                    dntShim.Deno.writeFileSync(ipexArgs.out, wire);
-                else
-                    deliveries.push(...yield* sendCredentialStream(runtime.postman, signer, recipient, [wire]));
-                return { admit: prepared.admit, grant, credential, saved, deliveries };
-            }
             const publication = yield* publishInitialGroupIpex(hby, runtime.protocol, runtime.postman, hab, wire, genus);
             deliveries.push(...publication.deliveries);
             const complete = yield* waitForGroupIpexApproval(hby, runtime.protocol, prepared.admit.said, ipexArgs.approvalTimeoutSeconds, reger);
@@ -251,10 +277,7 @@ export function* ipexAdmitCommand(args) {
                 }
             }
             return { admit: prepared.admit, grant, credential, saved, deliveries, group: { ...publication, complete, lead } };
-        }
-        finally {
-            yield* host.halt();
-        }
+        });
     });
 }
 /** Implement `tufa ipex list` by printing locally accepted IPEX EXNs. */
@@ -281,55 +304,30 @@ export function* ipexPollCommand(args) {
     const timeoutMs = nonNegativeNumber(args.timeout, 40, "poll timeout seconds") * 1000;
     return yield* withIpexRuntime(ipexArgs, function* ({ hby, runtime, reger }) {
         const hab = ipexArgs.alias ? requireHab(hby, ipexArgs.alias) : undefined;
-        const beforeExns = new Set([...hby.db.exns.getTopItemIter()]
-            .map(([, exn]) => exn.said)
-            .filter((said) => typeof said === "string"));
-        const beforeSaved = savedCredentials(reger);
-        let batchesSeen = 0;
-        let messagesSeen = 0;
+        const arrivals = { hby, reger };
+        const baseline = ipexBaseline(arrivals);
+        const tally = new MailboxIntakeTally();
         const signer = hab && isLocalGroupHab(hby, hab) ? localGroupMember(hby, hab.pre) : hab;
-        const deadline = Date.now() + timeoutMs;
-        let receiving = 0;
-        const host = yield* spawn(() => runAgentRuntime(runtime, { hab: signer, pollMailbox: false }));
-        try {
+        // The CLI has no running runtime: it runs the workers and a mailbox poller around the library wait.
+        const result = yield* withRuntimeWorkers(runtime, { hab: signer, pollMailbox: false }, function* () {
             const mailbox = yield* spawn(function* () {
-                yield* runtime.mailboxPoller.pollDo(function* (batch) {
-                    receiving++;
-                    try {
-                        yield* settleMailboxPollBatch(runtime, batch);
-                        batchesSeen++;
-                        messagesSeen += batch.messages.length;
-                    }
-                    finally {
-                        receiving--;
-                    }
-                });
+                yield* runtime.mailboxPoller.pollDo((batch) => tally.track(batch, () => settleMailboxPollBatch(runtime, batch)));
             });
             try {
-                while (true) {
-                    yield* processStoredCredentialGrants(hby, runtime, reger, ipexArgs.gvrsn);
-                    // State may become visible before the rest of a delivered batch settles.
-                    if (receiving === 0
-                        && (newIpexMessages(hby, beforeExns).length > 0 || newSavedCredentials(reger, beforeSaved).length > 0)) {
-                        break;
-                    }
-                    if (Date.now() >= deadline)
-                        break;
-                    yield* sleep(Math.min(250, deadline - Date.now()));
-                }
+                return yield* waitForIpexArrival({
+                    ...arrivals,
+                    settle: () => settleStoredGrants({ ...arrivals, hby, protocol: runtime.protocol }, ipexArgs.gvrsn),
+                }, baseline, { timeoutMs, tally });
             }
             finally {
                 yield* mailbox.halt();
             }
-        }
-        finally {
-            yield* host.halt();
-        }
+        });
         return {
-            batches: batchesSeen,
-            messages: messagesSeen,
-            ipex: newIpexMessages(hby, beforeExns),
-            saved: newSavedCredentials(reger, beforeSaved),
+            batches: tally.batches,
+            messages: tally.messages,
+            ipex: result.status.ipex,
+            saved: result.status.saved,
         };
     });
 }
@@ -376,6 +374,28 @@ export function* joinIpexProposal(hby, runtime, reger, ipexArgs) {
     if (!ipexArgs.auto) {
         return { exn, group: { embedded, accepted: null, approved: null, lead: null, messages: [], deliveries: [] } };
     }
+    if (embedded.pvrsn.major === 2) {
+        // ACDC v2: the runtime's group IPEX owner approves, publishes, collects and lets the lead deliver.
+        const ops = runtime.operations?.groupIpex;
+        if (!ops)
+            throw new ValidationError("ACDC v2 group IPEX requires the runtime's operation owners.");
+        const said = embedded.said;
+        if (!ops.live.has(said))
+            yield* approveGroupIpex(ops, said);
+        yield* withRuntimeWorkers(runtime, { hab: localGroupMember(hby, group), pollMailbox: true }, () => waitForGroupIpex(ops, said, { timeoutMs: ipexArgs.approvalTimeoutSeconds * 1000 }));
+        const outcome = ops.outcomes.get(said);
+        return {
+            exn,
+            group: {
+                embedded,
+                accepted: runtime.exc.complete(said),
+                approved: true,
+                lead: runtime.exc.lead(hby.habs.get(group), said),
+                messages: outcome?.messages ?? [],
+                deliveries: [...(outcome?.deliveries ?? []), ...(outcome?.sent ?? [])],
+            },
+        };
+    }
     const host = yield* spawn(() => runAgentRuntime(runtime, { hab: localGroupMember(hby, group) }));
     let credentialSaved;
     try {
@@ -384,7 +404,7 @@ export function* joinIpexProposal(hby, runtime, reger, ipexArgs) {
                 throw new ValidationError("VDR runtime did not open Reger.");
             const prior = embedded.ked?.p;
             const grant = typeof prior === "string" && prior.length > 0 ? hby.db.exns.get([prior]) : null;
-            credentialSaved = !!grant && (yield* settleGrantCredential(hby, runtime.protocol, reger, grant, group, ipexArgs.gvrsn, ipexArgs.approvalTimeoutSeconds));
+            credentialSaved = !!grant && (yield* settleAndWaitForCredential(hby, runtime.protocol, reger, grant, group, ipexArgs.gvrsn, ipexArgs.approvalTimeoutSeconds));
             if (!credentialSaved) {
                 return {
                     exn,
@@ -441,54 +461,37 @@ function* sendPriorResponse(args, route, priorLabel) {
     return yield* withIpexRuntime(ipexArgs, function* ({ hby, runtime }) {
         const hab = requireHab(hby, ipexArgs.alias);
         const recipient = new Organizer(hby.db, hby.signator).resolveRecipient(requireString(ipexArgs.recipient, "Recipient"));
-        requireConversationPrior(hby, hab, recipient, prior, "agree");
-        const prepared = exchange(route, { m: ipexArgs.message ?? "" }, { sender: hab.pre, recipient, dig: prior });
-        return yield* sendConversation(hby, runtime, hab, recipient, prepared, timeout);
+        if (isLocalGroupHab(hby, hab)) {
+            requireIpexPrior(hby, hab.pre, recipient, prior, "agree");
+            // TODO(group proposal API): replace with the multisig proposal API from app/multisig/counseling.ts.
+            const prepared = exchange(route, { m: ipexArgs.message ?? "" }, { sender: hab.pre, recipient, dig: prior });
+            return yield* sendGroupConversation(hby, runtime, hab, recipient, prepared, timeout);
+        }
+        return yield* withRuntimeWorkers(runtime, { hab }, () => sendIpexAgree(ipexSendDeps(hby, runtime), hab, { recipient, offer: prior, message: ipexArgs.message }));
     });
 }
 /** Validate an accepted predecessor and its known parties before any local signing. */
 function requireConversationPrior(hby, hab, recipient, said, verb) {
-    const prior = hby.db.exns.get([said]);
-    if (!prior)
-        throw new ValidationError("Prior IPEX exchange is not accepted.");
-    validateIpexReply(prior, verb, hab.pre, recipient);
-    if (hby.db.erpy.get([said])) {
-        throw new ValidationError("Prior IPEX exchange already has an accepted response; resume the existing exchange.");
-    }
+    requireIpexPrior(hby, hab.pre, recipient, said, verb);
+}
+/** Collaborators for the library send operations, adapted once from the command runtime. */
+function ipexSendDeps(hby, runtime) {
+    return { hby, reactor: runtime.reactor, protocol: runtime.protocol, postman: runtime.postman };
 }
 /**
- * Run one command host through local intake, member approval and concrete delivery.
- * Local conversation state survives transport failure. Group publication and business
- * acceptance are separate facts; only an accepted child's elected member sends it
- * externally. The caller's resource scope closes stores after this host joins.
+ * Run one group command host through local intake, member approval and concrete delivery.
+ * Group publication and business acceptance are separate facts; only an accepted
+ * child's elected member sends it externally. The caller's resource scope closes
+ * stores after this host joins. Single-signature sends use `sendIpex*`.
  */
-function* sendConversation(hby, runtime, hab, recipient, [exn, attachments], timeout) {
-    const group = isLocalGroupHab(hby, hab);
+function* sendGroupConversation(hby, runtime, hab, recipient, [exn, attachments], timeout) {
     const genus = exn.gvrsn ?? exn.pvrsn;
-    const wire = group
-        ? groupIpexPartial(hby, hab, exn, attachments, genus)
-        : concatBytes(hab.endorse(exn, { pipelined: false, gvrsn: genus }), attachments);
-    const signer = group ? localGroupMember(hby, hab.pre) : hab;
-    const host = yield* spawn(() => runAgentRuntime(runtime, { hab: signer, pollMailbox: group }));
+    const wire = groupIpexPartial(hby, hab, exn, attachments, genus);
+    const signer = localGroupMember(hby, hab.pre);
+    const host = yield* spawn(() => runAgentRuntime(runtime, { hab: signer, pollMailbox: true }));
     try {
         yield* runtime.reactor.processBytes(concatBytes(Counter.makeGVC(genus), wire), { local: true });
         yield* runtime.protocol.processEscrowsOnce();
-        if (!group) {
-            if (!runtime.exc.complete(exn.said))
-                throw new ValidationError("Local IPEX exchange was not accepted.");
-            let deliveries;
-            if (exn.route === IPEX_SPURN_ROUTE) {
-                deliveries = yield* sendCredentialStream(runtime.postman, hab, recipient, [wire]);
-            }
-            else {
-                const evt = runtime.postman.send({ src: hab.pre, dest: recipient, topic: CREDENTIAL_MAILBOX_TOPIC, msg: wire }, { notify: true });
-                const outcome = yield* runtime.postman.wait(evt);
-                if (outcome.kin === "failed")
-                    throw outcome.error;
-                deliveries = outcome.deliveries;
-            }
-            return { exn, deliveries };
-        }
         const publication = yield* publishInitialGroupIpex(hby, runtime.protocol, runtime.postman, hab, wire, genus);
         const complete = yield* waitForGroupIpexApproval(hby, runtime.protocol, exn.said, timeout, null);
         const lead = complete ? runtime.exc.lead(hab, exn.said) : null;
@@ -554,37 +557,6 @@ function requireNonEmpty(value, label) {
         throw new ValidationError(`${label} is required and cannot be empty.`);
     }
 }
-function newIpexMessages(hby, before) {
-    const messages = [];
-    for (const [, exn] of hby.db.exns.getTopItemIter()) {
-        const said = exn.said;
-        const route = exn.route ?? "";
-        if (!said || before.has(said) || !route.startsWith("/ipex/")) {
-            continue;
-        }
-        messages.push(exn);
-    }
-    return messages;
-}
-function savedCredentials(reger) {
-    return new Set([...reger.saved.getTopItemIter()].map(([keys]) => keys[0]).filter((key) => !!key));
-}
-function newSavedCredentials(reger, before) {
-    return [...savedCredentials(reger)].filter((said) => !before.has(said));
-}
-/** Settle accepted grant artifacts before the poll command reports newly saved credentials. */
-function* processStoredCredentialGrants(hby, runtime, reger, gvrsn) {
-    for (const [, grant] of hby.db.exns.getTopItemIter()) {
-        if (grant.route !== IPEX_GRANT_ROUTE) {
-            continue;
-        }
-        const credentialSaid = credentialSaidFromGrant(grant);
-        if (!credentialSaid || reger.saved.get([credentialSaid])) {
-            continue;
-        }
-        yield* processCredentialPresentationArtifacts(runtime.protocol, storedGrantArtifacts(hby, grant, gvrsn));
-    }
-}
 function parseJsonArg(value) {
     if (!value) {
         return undefined;
@@ -643,18 +615,13 @@ function grantSender(grant) {
  * escrow progress. The caller runs the host and selects the elapsed wait; no
  * admit signature is produced here. Missing evidence remains pending on expiry.
  */
-function* settleGrantCredential(hby, protocol, reger, grant, recipient, genus, timeout) {
-    const said = validateAdmitGrant(grant, recipient, reger, false);
-    if (reger.saved.get([said]))
-        return true;
-    const deadline = Date.now() + timeout * 1000;
-    yield* processCredentialPresentationArtifacts(protocol, storedGrantArtifacts(hby, grant, genus));
-    while (!reger.saved.get([said])) {
-        if (Date.now() >= deadline)
-            return false;
-        yield* sleep(Math.min(250, deadline - Date.now()));
-    }
-    return true;
+function* settleAndWaitForCredential(hby, protocol, reger, grant, recipient, genus, timeout) {
+    yield* settleGrantCredential({ hby, reger, protocol }, recipient, grant.said, { gvrsn: genus });
+    const waited = yield* waitForIpexExchange({ hby, reger }, grant.said, {
+        timeoutMs: timeout * 1000,
+        until: "credential-saved",
+    });
+    return waited.outcome === "settled";
 }
 /**
  * Observe one child's approvals under an elapsed deadline. The command's existing