keri-ts 2.0.1 → 2.2.0

package/esm/keri/npm/src/app/identity/challenging.js

@@ -1,4 +1,9 @@
 import { Diger } from "cesr-ts";
+import { ValidationError } from "../../core/errors.js";
+import { sendExchangeMessage } from "../exchanges/exchange-messaging.js";
+import { systemClock } from "../runtime/runtime-clock.js";
+import { observeUntil } from "../runtime/workflow-contract.js";
+import { isLocalGroupHab } from "./endpoint-roleing.js";
 const CHALLENGE_CONSONANTS = [
     "b",
     "c",
@@ -91,6 +96,51 @@ export function findVerifiedChallengeResponse(db, signer, expected) {
     }
     return null;
 }
+/**
+ * Respond to a challenge: sign and send a `/challenge/response` exchange message
+ * carrying `words` to `recipient`. Each call authors a new message (the exchange
+ * carries a timestamp); the verifier's matching is idempotent over repeats.
+ *
+ * @returns The signed exchange message that was sent.
+ * @throws ValidationError for a group habitat or empty words; send failures propagate.
+ */
+export function* respondToChallenge(deps, hab, recipient, words) {
+    if (isLocalGroupHab(deps.hby, hab)) {
+        throw new ValidationError("Challenge respond does not coordinate group approval. Select the responding member alias.");
+    }
+    if (words.length === 0)
+        throw new ValidationError("Challenge words must not be empty.");
+    const payload = { words: [...words] };
+    const { serder } = yield* sendExchangeMessage(deps.hby, hab, deps.http, deps.clock, {
+        dest: recipient,
+        route: CHALLENGE_RESPONSE_ROUTE,
+        topic: "challenge",
+        payload: { i: hab.pre, ...payload },
+    });
+    return serder;
+}
+/** Read the status of `words` from `signer`; mutates nothing. */
+export function challengeStatus(deps, signer, words) {
+    const response = findVerifiedChallengeResponse(deps.db, signer, words);
+    if (!response)
+        return { state: "waiting" };
+    const recorded = deps.db.chas.get([signer]).some((diger) => diger.qb64 === response.said);
+    return { state: recorded ? "verified" : "received", response };
+}
+/**
+ * Observe stored exchange messages until a response with the expected words from
+ * `signer` arrives or the budget expires. Starts no worker: the host's runtime
+ * (mailbox polling, exchange intake) is what stores the response.
+ */
+export function* waitForChallengeResponse(deps, signer, words, { timeoutMs, pollMs = 250, clock = systemClock }) {
+    const done = yield* observeUntil(() => challengeStatus(deps, signer, words).state !== "waiting", {
+        timeoutMs,
+        pollMs,
+        clock,
+    });
+    const status = challengeStatus(deps, signer, words);
+    return done ? { outcome: "settled", status } : { outcome: "timed-out", status, timeoutMs };
+}
 /** Persist one verifier-confirmed challenge response in `chas.`. */
 export function markChallengeVerified(db, signer, serder) {
     if (!serder.said) {

package/esm/keri/npm/src/app/identity/configing.js

@@ -1,5 +1,5 @@
 import * as dntShim from "../../_dnt.shims.js";
-import { basename, dirname, join } from "../../deps/jsr.io/@std/path/1.1.6/mod.js";
+import { basename, dirname, extname, join } from "../../deps/jsr.io/@std/path/1.1.6/mod.js";
 import { ValidationError } from "../../core/errors.js";
 import { PathManager } from "../../db/core/path-manager.js";
 const CONFIGER_DEFAULTS = {
@@ -23,7 +23,7 @@ const CONFIGER_DEFAULTS = {
  * - currently supports JSON only
  */
 export class Configer {
-    /** Create a config manager bound to a PathManager-backed directory. */
+    /** Create a config manager bound to a PathManager-resolved file. */
     constructor(options = {}) {
         Object.defineProperty(this, "name", {
             enumerable: true,
@@ -62,7 +62,7 @@ export class Configer {
             value: null
         });
         this.name = options.name || "conf";
-        this.base = options.base || "";
+        this.base = options.base ?? "main";
         this.temp = options.temp || false;
         this.fext = options.fext || CONFIGER_DEFAULTS.fext;
         this.pathManager = new PathManager({
@@ -70,27 +70,24 @@ export class Configer {
             name: this.name,
             base: this.base,
             temp: this.temp,
+            filed: true,
+            fext: this.fext,
         }, {
             tailDirPath: CONFIGER_DEFAULTS.tailDirPath,
             cleanTailDirPath: CONFIGER_DEFAULTS.cleanTailDirPath,
-            altTailDirPath: CONFIGER_DEFAULTS.altTailDirPath,
-            altCleanTailDirPath: CONFIGER_DEFAULTS.altCleanTailDirPath,
+            altTailDirPath: options.compat ? ".keri/cf" : CONFIGER_DEFAULTS.altTailDirPath,
+            altCleanTailDirPath: options.compat ? ".keri/clean/cf" : CONFIGER_DEFAULTS.altCleanTailDirPath,
             tempPrefix: CONFIGER_DEFAULTS.tempPrefix,
         });
     }
     get opened() {
         return this.path !== null;
     }
-    /** Resolve and validate the config filename and extension. */
-    resolvedFileName() {
-        if (this.name.endsWith(`.${this.fext}`)) {
-            return this.name;
-        }
-        const hasExt = this.name.includes(".");
-        if (hasExt) {
+    /** Refuse a config name carrying an extension this manager cannot read. */
+    assertSupportedExtension() {
+        if (extname(this.name) && !this.name.endsWith(`.${this.fext}`)) {
             throw new ValidationError(`Unsupported config extension for '${this.name}'. Only .${this.fext} is supported.`);
         }
-        return `${this.name}.${this.fext}`;
     }
     ensureOpenPath() {
         if (!this.path) {
@@ -194,44 +191,21 @@ export class Configer {
             throw pendingError;
         }
     }
-    /** Open or create the config file in the resolved Configer directory. */
+    /** Open the config file at KERIpy's `{head}/keri/cf/{base}/{name}.{fext}`, creating it when absent. */
     *reopen(options = {}) {
-        const opened = yield* this.pathManager.reopen({
-            ...options,
-            name: this.name,
-            base: this.base,
-            temp: this.temp,
-        });
+        this.assertSupportedExtension();
+        const opened = yield* this.pathManager.reopen(options);
         if (!opened || !this.pathManager.path) {
             return false;
         }
-        const fileName = this.resolvedFileName();
-        this.path = join(this.pathManager.path, fileName);
-        try {
-            dntShim.Deno.statSync(this.path);
-        }
-        catch (error) {
-            if (error instanceof dntShim.Deno.errors.NotFound) {
-                this.writeAtomic(this.path, "{}\n");
-            }
-            else {
-                throw error;
-            }
+        this.path = this.pathManager.path;
+        if (dntShim.Deno.statSync(this.path).size === 0) {
+            this.writeAtomic(this.path, "{}\n");
         }
         return true;
     }
-    /** Close the config manager and optionally remove files. */
+    /** Close the config manager and optionally remove the file. */
     *close(clear = false) {
-        if (clear && this.path) {
-            try {
-                dntShim.Deno.removeSync(this.path);
-            }
-            catch (error) {
-                if (!(error instanceof dntShim.Deno.errors.NotFound)) {
-                    throw error;
-                }
-            }
-        }
         this.path = null;
         yield* this.pathManager.close(clear);
         return true;

package/esm/keri/npm/src/app/identity/delegating.js

@@ -90,7 +90,7 @@ function escrowContext(keys, serder) {
     return [keys, serder, pre, said, snh];
 }
 /** Persist the delegator event seal that authorizes one delegated event. */
-function pinAuthorizingSeal(hby, delegated, delegating) {
+export function pinAuthorizingSeal(hby, delegated, delegating) {
     const pre = delegated.pre;
     const said = delegated.said;
     const sner = delegating.sner;
@@ -226,6 +226,72 @@ Object.defineProperty(DelegateRequestHandler, "resource", {
     writable: true,
     value: DELEGATE_REQUEST_ROUTE
 });
+/** Enqueue one anchor query to the delegator's first sorted witness, when its endpoint is known. */
+function enqueueAnchorQuery(deps, serder, delpre, witness, communicationHab) {
+    deps.querying.enqueue({
+        pre: delpre,
+        route: "logs",
+        q: { fn: "0", s: "0", a: eventAnchor(serder) },
+        signer: communicationHab.pre,
+        wits: [witness],
+    });
+}
+/**
+ * Publish the initial delegator-witness anchor query and seed the retry-pass
+ * bookkeeping so the first retry starts the backoff window instead of querying again.
+ */
+export function queueDelegatorWitnessQuery(deps, serder, communicationHab) {
+    const id = workflowId(serder);
+    const delpre = delegatedWorkflowDelpre(deps.hby, serder);
+    if (!delpre) {
+        throw new ValidationError(`Delegation workflow ${id} is missing a delegator prefix.`);
+    }
+    const delegator = deps.hby.db.getKever(delpre);
+    if (!delegator) {
+        return;
+    }
+    const witness = firstSorted(delegator.wits);
+    if (!witness || !preferredWitnessQueryUrl(communicationHab, witness)) {
+        return;
+    }
+    enqueueAnchorQuery(deps, serder, delpre, witness, communicationHab);
+    deps.retryPasses.set(id, -1);
+}
+/** Retry bounded delegator-witness queries while waiting for the anchor; returns why the wait continues. */
+export function retryDelegatorWitnessQuery(deps, serder, communicationHab) {
+    const id = workflowId(serder);
+    const delpre = delegatedWorkflowDelpre(deps.hby, serder);
+    if (!delpre) {
+        throw new ValidationError(`Delegation workflow ${id} is missing a delegator prefix.`);
+    }
+    const delegator = deps.hby.db.getKever(delpre);
+    if (!delegator) {
+        return "Delegator anchor has not been learned locally yet and the delegator KEL is not known locally.";
+    }
+    const witness = firstSorted(delegator.wits);
+    if (!witness) {
+        return "Delegator anchor has not been learned locally yet and no delegator witness is known locally.";
+    }
+    if (!preferredWitnessQueryUrl(communicationHab, witness)) {
+        return `Delegator anchor has not been learned locally yet and witness ${witness} has no HTTP endpoint known locally.`;
+    }
+    const pass = deps.retryPasses.get(id);
+    if (pass === undefined) {
+        enqueueAnchorQuery(deps, serder, delpre, witness, communicationHab);
+        deps.retryPasses.set(id, 0);
+        return `Delegator anchor has not been learned locally yet; queried delegator witness ${witness}.`;
+    }
+    const nextPass = pass + 1;
+    if (nextPass < DELEGATION_ANCHOR_QUERY_RETRY_PASSES) {
+        deps.retryPasses.set(id, nextPass);
+        const remaining = DELEGATION_ANCHOR_QUERY_RETRY_PASSES
+            - nextPass;
+        return `Delegator anchor has not been learned locally yet; next delegator witness query retry in ${remaining} pass(es).`;
+    }
+    enqueueAnchorQuery(deps, serder, delpre, witness, communicationHab);
+    deps.retryPasses.set(id, 0);
+    return `Delegator anchor has not been learned locally yet; queried delegator witness ${witness}.`;
+}
 /**
  * Delegation workflow coordinator for delegated inception and rotation events.
  *
@@ -329,6 +395,13 @@ export class Anchorer {
             writable: true,
             value: new Map()
         });
+        /** Shared anchor-discovery inputs over this owner's collaborators and retry bookkeeping. */
+        Object.defineProperty(this, "anchorQuery", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         if (protocol && protocol.kvy.db !== hby.db) {
             throw new RangeError("Anchorer protocol processor must use the same database");
         }
@@ -336,6 +409,7 @@ export class Anchorer {
         this.protocol = protocol;
         this.postman = postman;
         this.querying = querying;
+        this.anchorQuery = { hby, querying, retryPasses: this.anchorQueryRetryPasses };
         this.http = http;
         this.clock = clock;
     }
@@ -531,7 +605,7 @@ export class Anchorer {
         // publish phase that forwards the delegation request and raw event bytes.
         // Keep that ordering here so delegate-side approval discovery does not
         // depend on a later escrow pass happening "soon enough" by accident.
-        this.queueDelegatorWitnessQueryNow(serder, communicationHab);
+        queueDelegatorWitnessQuery(this.anchorQuery, serder, communicationHab);
         this.hby.db.dpwe.rem(keys);
         this.hby.db.dune.pin(keys, serder);
         return {
@@ -579,7 +653,7 @@ export class Anchorer {
                 pre,
                 said,
                 phase: "waitingDelegatorAnchor",
-                reason: this.retryDelegatorWitnessQuery(serder, communicationHab),
+                reason: retryDelegatorWitnessQuery(this.anchorQuery, serder, communicationHab),
             };
         }
         // The approving event is authoritative only after the delegator's sealing
@@ -634,80 +708,6 @@ export class Anchorer {
         }
         throw new ValidationError(`Delegated inception for ${hab.pre} requires --proxy <alias> to send delegation requests.`);
     }
-    /** Publish the initial anchor query after successful sending and seed the existing retry-pass bookkeeping. */
-    queueDelegatorWitnessQueryNow(serder, communicationHab) {
-        const id = workflowId(serder);
-        const delpre = delegatedWorkflowDelpre(this.hby, serder);
-        if (!delpre) {
-            throw new ValidationError(`Delegation workflow ${id} is missing a delegator prefix.`);
-        }
-        const delegator = this.hby.db.getKever(delpre);
-        if (!delegator) {
-            return;
-        }
-        const witness = firstSorted(delegator.wits);
-        if (!witness || !preferredWitnessQueryUrl(communicationHab, witness)) {
-            return;
-        }
-        this.querying.enqueue({
-            pre: delpre,
-            route: "logs",
-            q: { fn: "0", s: "0", a: eventAnchor(serder) },
-            signer: communicationHab.pre,
-            wits: [witness],
-        });
-        // Mark that an immediate publication-time query was already sent so the
-        // first unanchored escrow retry pass starts the backoff window instead of
-        // immediately enqueueing the same query again.
-        this.anchorQueryRetryPasses.set(id, -1);
-    }
-    /** Retry bounded delegator-witness queries while waiting for the anchor. */
-    retryDelegatorWitnessQuery(serder, communicationHab) {
-        const id = workflowId(serder);
-        const delpre = delegatedWorkflowDelpre(this.hby, serder);
-        if (!delpre) {
-            throw new ValidationError(`Delegation workflow ${id} is missing a delegator prefix.`);
-        }
-        const delegator = this.hby.db.getKever(delpre);
-        if (!delegator) {
-            return "Delegator anchor has not been learned locally yet and the delegator KEL is not known locally.";
-        }
-        const witness = firstSorted(delegator.wits);
-        if (!witness) {
-            return "Delegator anchor has not been learned locally yet and no delegator witness is known locally.";
-        }
-        if (!preferredWitnessQueryUrl(communicationHab, witness)) {
-            return `Delegator anchor has not been learned locally yet and witness ${witness} has no HTTP endpoint known locally.`;
-        }
-        const pass = this.anchorQueryRetryPasses.get(id);
-        if (pass === undefined) {
-            this.querying.enqueue({
-                pre: delpre,
-                route: "logs",
-                q: { fn: "0", s: "0", a: eventAnchor(serder) },
-                signer: communicationHab.pre,
-                wits: [witness],
-            });
-            this.anchorQueryRetryPasses.set(id, 0);
-            return `Delegator anchor has not been learned locally yet; queried delegator witness ${witness}.`;
-        }
-        const nextPass = pass + 1;
-        if (nextPass < DELEGATION_ANCHOR_QUERY_RETRY_PASSES) {
-            this.anchorQueryRetryPasses.set(id, nextPass);
-            const remaining = DELEGATION_ANCHOR_QUERY_RETRY_PASSES
-                - nextPass;
-            return `Delegator anchor has not been learned locally yet; next delegator witness query retry in ${remaining} pass(es).`;
-        }
-        this.querying.enqueue({
-            pre: delpre,
-            route: "logs",
-            q: { fn: "0", s: "0", a: eventAnchor(serder) },
-            signer: communicationHab.pre,
-            wits: [witness],
-        });
-        this.anchorQueryRetryPasses.set(id, 0);
-        return `Delegator anchor has not been learned locally yet; queried delegator witness ${witness}.`;
-    }
     /** Retire only this event's process-local signer and query bookkeeping. */
     clearWorkflowPins(serder) {
         const id = workflowId(serder);