keri-ts 2.1.0 → 2.2.0

package/esm/keri/npm/src/app/ipex/receive-issuance.js

@@ -0,0 +1,86 @@
+import { race } from "effection";
+import { ValidationError } from "../../core/errors.js";
+import { waitOnClock } from "../runtime/workflow-contract.js";
+import { admitIssuance, approveIssuanceExchange, deliverIssuanceAdmit, issuanceStatus, waitForIssuance, } from "./issuance.js";
+/** Default budget of delivering an Admit, in milliseconds. */
+export const ADMIT_DELIVERY_TIMEOUT_MS = 30_000;
+/** How a delivery of `deliver: false` reads. */
+const NOT_DELIVERED = "Delivery was not requested.";
+/**
+ * Sign and accept the Admit, run `onAdmitted`, then deliver within the budget. A failed or expired delivery is a
+ * value; the Admit stays accepted and `rebuildIssuanceAdmit` can send it again.
+ *
+ * @throws ValidationError as {@link admitIssuance} does, and whatever `onAdmitted` throws.
+ */
+export function* admitAndDeliver(deps, input) {
+    const { grant, message, gvrsn, auths, onAdmitted } = input;
+    const admitted = yield* admitIssuance(deps, grant, { message, gvrsn, auths });
+    // The host's record precedes delivery: whatever happens to the network, its consent is on record.
+    if (onAdmitted)
+        yield* onAdmitted(admitted);
+    if (input.deliver === false)
+        return { admitted, delivery: { state: "undelivered", reason: NOT_DELIVERED } };
+    const budget = input.deliveryTimeoutMs ?? ADMIT_DELIVERY_TIMEOUT_MS;
+    const expired = {
+        state: "undelivered",
+        reason: `Delivery did not finish within ${budget} ms.`,
+    };
+    try {
+        const delivery = yield* race([
+            (function* () {
+                return { state: "delivered", to: yield* deliverIssuanceAdmit(deps.delivery, admitted) };
+            })(),
+            (function* () {
+                yield* waitOnClock(deps.clock, budget);
+                return expired;
+            })(),
+        ]);
+        return { admitted, delivery };
+    }
+    catch (error) {
+        if (!(error instanceof Error))
+            throw error;
+        return { admitted, delivery: { state: "undelivered", reason: error.message } };
+    }
+}
+/**
+ * The individual holder's whole path for a Grant addressed to a local identifier: approve the DH exchange when it is pending,
+ * wait for the issuer to finish it, then admit and deliver ({@link admitAndDeliver}).
+ *
+ * @throws ValidationError for a Grant that is not addressed to a local identifier, one this runtime issued, or a
+ * group identifier.
+ */
+export function* receiveIssuance(ops, input) {
+    const { grant, timeoutMs } = input, { deps } = ops;
+    const first = issuanceStatus(ops, grant);
+    if (first.role === "issuer")
+        throw new ValidationError("This Grant was issued by this runtime.");
+    if (first.state === "active" && first.needs === "exchange")
+        approveIssuanceExchange(ops, grant);
+    const waited = yield* waitForIssuance(ops, grant, {
+        timeoutMs,
+        until: (status) => status.state !== "active" || status.needs === "admit",
+    });
+    const { status } = waited;
+    if (waited.outcome === "timed-out")
+        return { outcome: "timed-out", grant, timeoutMs, status };
+    if (status.state === "done") {
+        const admit = deps.hby.db.erpy.get([grant]).qb64;
+        return {
+            outcome: "admitted",
+            grant,
+            admit,
+            delivery: { state: "undelivered", reason: "Admitted by an earlier call; rebuild and send it to deliver again." },
+        };
+    }
+    if (status.state !== "active")
+        return { outcome: "ended", grant, status };
+    const done = yield* admitAndDeliver(deps, input);
+    return {
+        outcome: "admitted",
+        grant,
+        admit: done.admitted.admit.said,
+        admitted: done.admitted,
+        delivery: done.delivery,
+    };
+}