keri-ts 2.2.0 → 2.2.2

package/esm/keri/npm/src/cli/messaging/group-join.js

@@ -3,7 +3,8 @@
  *
  * Join approves exactly one stored proposal, the first the user consents to:
  * - an explicit `--said` names the proposal, otherwise the unapproved proposals
- *   the notice store announces are offered in notice order;
+ *   the notice store announces are offered in notice order; `--kind` restricts the
+ *   offer (and a `--said`) to one proposal kind, so a join never signs another kind;
  * - without `--auto` every offered proposal is shown and approved only on a yes;
  * - with `--auto` the first offered proposal is approved without a prompt. This is
  *   the whole of auto consent: it exists only inside the `join` the user ran for
@@ -19,17 +20,20 @@ function joinedGroup(hby, group) {
     return group === undefined ? undefined : (hby.habByName(group) ?? hby.habs.get(group))?.pre ?? undefined;
 }
 /** Candidates for one pass, oldest first. */
-function candidates(deps, { said, group }) {
+function candidates(deps, { said, group, kind }) {
     const wanted = joinedGroup(deps.hby, group);
     if (said !== undefined) {
         const proposal = findGroupProposal(deps, said);
+        if (proposal && kind !== undefined && proposal.kind !== kind) {
+            throw new ValidationError(`Multisig exchange ${said} is a ${proposal.kind} proposal, not ${kind}.`);
+        }
         if (proposal && wanted !== undefined && proposal.group !== wanted) {
             throw new ValidationError(`Multisig exchange ${said} belongs to group ${proposal.group}, not ${wanted}.`);
         }
         return proposal ? [proposal] : [];
     }
     return listGroupProposals(deps, wanted === undefined ? {} : { group: wanted })
-        .filter(proposal => proposal.local === "unapproved");
+        .filter(proposal => proposal.local === "unapproved" && (kind === undefined || proposal.kind === kind));
 }
 /**
  * Approve the first proposal the user consents to, polling stored proposals until

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

@@ -32,12 +32,32 @@ import { rootCopyLine } from "./root-copy-lines.js";
  * 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 replicating = runtime.rootReplicator;
-    if (!hby.habs.get(group) || !replicating)
+function* resealAfterRotation(hby, runtime, group, rotation, since) {
+    const replicating = runtime.rootReplicator, root = runtime.registryRoot;
+    if (!hby.habs.get(group) || !replicating || !root)
         return [];
     replicating.prompt(group);
-    return (yield* replicating.processOnce()).map(rootCopyLine);
+    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) {
@@ -122,15 +142,18 @@ 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 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),
@@ -138,7 +161,7 @@ export function* multisigJoinCommand(args) {
             inputs: () => ({ fallbackAfterMs: 0 }),
         });
         if (!joined) {
-            const local = yield* completeLocalGroupEvent(hby, runtime, commandArgs, deadline);
+            const local = yield* completeLocalGroupEvent(hby, runtime, commandArgs, deadline, since);
             if (!local) {
                 throw new ValidationError("No matching stored multisig proposal was available to join.");
             }
@@ -168,7 +191,7 @@ export function* multisigJoinCommand(args) {
             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);
+        return yield* finishJoinedEvent(hby, runtime, result, event, commandArgs, since);
     });
 }
 /** Create or begin one group interaction event. */
@@ -232,6 +255,7 @@ 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 since = runtime.clock.now();
         const groupHab = requireGroupHab(hby, group);
         const sent = yield* proposeGroupRotation(proposeDeps(hby, runtime), groupHab, {
             smids: commandArgs.smids,
@@ -251,7 +275,7 @@ export function* multisigRotateCommand(args) {
             // The proposer's own acceptance must commit the rotated membership as a joiner's does.
             settleProposedRotation({ hby }, sent);
             delegationPhase = yield* finishAcceptedEvent(hby, runtime, sent.event, commandArgs);
-            rootCopies = yield* resealAfterRotation(hby, runtime, sent.group, sent.event.said);
+            rootCopies = yield* resealAfterRotation(hby, runtime, sent.group, sent.event.said, since);
         }
         return { ...groupEventResult(hby, sent, accepted), delegationPhase, rootCopies };
     });
@@ -371,6 +395,7 @@ function groupEventResult(hby, sent, accepted) {
         accepted,
         messages: sent.messages,
         deliveries: sent.deliveries,
+        members: sent.members,
         state: hby.db.getState(sent.group),
         delegationPhase: null,
     };
@@ -380,16 +405,16 @@ function groupEventResult(hby, sent, accepted) {
  * 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) {
+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) };
+    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) {
+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);
@@ -411,8 +436,9 @@ function* completeLocalGroupEvent(hby, runtime, args, deadline) {
         accepted,
         deliveries: [],
         messages: [],
+        members: [],
     };
-    return yield* finishJoinedEvent(hby, runtime, result, event, args);
+    return yield* finishJoinedEvent(hby, runtime, result, event, args, since);
 }
 function chooseRegistryName(args, regk) {
     if (args.registryName) {

package/esm/keri/npm/src/core/errors.js

@@ -6,29 +6,117 @@
  * opaque; domain processing never inspects them for instructions.
  */
 export class AppError extends Error {
-    constructor(message, options) {
-        super(message, options);
-        this.name = globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).name;
+    constructor() {
+        super(...arguments);
+        /**
+         * Every class names itself with a literal. `new.target.name` and `constructor.name` are not used: they are
+         * mangled by a minifier, and the dnt transform of `new.target` needs a polyfill the browser entries do not load.
+         */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "AppError"
+        });
     }
 }
 /** Invalid caller input or state transition at an application boundary. */
 export class ValidationError extends AppError {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ValidationError"
+        });
+    }
 }
 /** Filesystem or path-resolution failure from path-managed resources. */
 export class PathError extends AppError {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "PathError"
+        });
+    }
+}
+/**
+ * An Unblind was asked of a presentation whose exchange already has its terminal response (an Admit or a Spurn). The
+ * discloser consented to answer queries about a live presentation; the response ends that authority, so the
+ * Unblind must be requested before the response is made.
+ */
+export class PresentationClosedError extends ValidationError {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "PresentationClosedError"
+        });
+    }
 }
 /** Rejected path name because it violates relative-name constraints. */
 export class InvalidPathNameError extends ValidationError {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "InvalidPathNameError"
+        });
+    }
 }
 /** Base error for LMDB or higher-level database operations. */
 export class DatabaseError extends AppError {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "DatabaseError"
+        });
+    }
 }
 /** Database-dependent operation attempted before the resource was opened. */
 export class DatabaseNotOpenError extends DatabaseError {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "DatabaseNotOpenError"
+        });
+    }
 }
 /** Key encoding/shape failure while reading or writing database state. */
 export class DatabaseKeyError extends DatabaseError {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "DatabaseKeyError"
+        });
+    }
 }
 /** Operational LMDB/path failure during a database lifecycle step. */
 export class DatabaseOperationError extends DatabaseError {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "DatabaseOperationError"
+        });
+    }
 }