@dcasegr/skein 0.0.0-stage → 0.1.1

package/dist/host/clock.d.ts

@@ -0,0 +1,3 @@
+import { type Stamp } from "../runtime/syscalls.ts";
+/** Wall time now, ms resolution, as a stamp. */
+export declare function now(): Stamp;

package/dist/host/clock.js

@@ -0,0 +1,8 @@
+// The host's clock: the one place the node host reads wall time for a log
+// entry's stamp (a genesis, an admission). Nothing inside the kernel reads a
+// clock; everything there derives time from these stamps.
+import { msStamp } from "../runtime/syscalls.js";
+/** Wall time now, ms resolution, as a stamp. */
+export function now() {
+    return msStamp(Date.now());
+}

package/dist/host/control.d.ts

@@ -0,0 +1,45 @@
+import { type Server } from "node:net";
+export declare const CONTROL_SOCKET = "host.sock";
+export type ControlRequest = {
+    op: "event";
+    handle: string;
+    box: string;
+    event: Record<string, unknown>;
+} | {
+    op: "reclaim";
+    handle: string;
+} | {
+    op: "message";
+    handle: string;
+    message: string;
+    body: string;
+};
+export type ControlAnswer = {
+    ok: true;
+    entry: string;
+} | {
+    ok: false;
+    error: string;
+};
+/** What the socket's owner does with a request (the router: cronEvent). */
+export interface ControlHandler {
+    event(handle: string, box: string, event: Record<string, unknown>): Promise<string>;
+    /** #130: `skein-host reclaim --yes` (Router.reclaim); absent: refused. */
+    reclaim?(handle: string): Promise<void>;
+    /** #142: a signed message for `handle` (its mail record's dag-cbor and its body), appended as a `local` request (Router.messageLocal); absent: refused. */
+    message?(handle: string, message: Uint8Array, body: Uint8Array): Promise<string>;
+}
+/** The longest request line: ours to choose (#142) — a message carries a module whole (base64), so 64 MiB. */
+export declare const MAX_LINE: number;
+/**
+ * Listen on `path`: a socket left by a router that is gone is replaced; one
+ * that answers is another router's, and this one refuses to start on it.
+ */
+export declare function listenControl(path: string, h: ControlHandler): Promise<Server>;
+/** Close the socket and remove its file. */
+export declare function closeControl(server: Server, path: string): Promise<void>;
+/**
+ * Send one request to the router on `path`. Undefined if no router answers
+ * there (no socket, or one left by a router that is gone); its answer otherwise.
+ */
+export declare function controlRequest(path: string, req: ControlRequest, timeoutMs?: number): Promise<ControlAnswer | undefined>;

package/dist/host/control.js

@@ -0,0 +1,170 @@
+// The router's control socket (#60 follow-up): a Unix socket at
+// $SKEIN_HOME/host.sock, mode 0600 — owner-only by file permissions, and no
+// HTTP route leads to it. A running router listens on it so that a local
+// command can reach the kernels it already holds: a store has one kernel, and
+// a second process opening it would fork the log.
+//
+// The protocol is one JSON line each way, and it carries one request:
+//
+//   {"op": "event", "handle": h, "box": b, "event": {…}}   → {"ok": true, "entry": "<cid>"} | {"ok": false, "error": "…"}
+//   {"op": "reclaim", "handle": h}                       → {"ok": true, "entry": ""} | {"ok": false, "error": "…"}
+//   {"op": "message", "handle": h, "message": "<base64>", "body": "<base64>"}
+//                                                       → {"ok": true, "entry": "<cid>"} | {"ok": false, "error": "…"}
+//
+// `event` is `skein-host event` (cli.ts): the router sends it as a message
+// from its cron provider, a tick due now (Router.cronEvent, #69).
+// `message` (#142) is a message the client `skein` signed in its own process
+// (src/client/raw.ts signMessage: the operator's key), delivered on the host
+// machine: `message` its mail record's dag-cbor, `body` the body's bytes. The
+// router appends it as received, a `local` request (Router.messageLocal →
+// appendLocal, the path a forwarded claim takes): the front door checks its
+// signature and admits it by the dispatch table, as any signed message. The
+// router signs nothing; the answer is the entry, once the front door has
+// judged it (a refusal is an error).
+import { chmodSync, existsSync, unlinkSync } from "node:fs";
+import { createConnection, createServer } from "node:net";
+export const CONTROL_SOCKET = "host.sock";
+/** The longest request line: ours to choose (#142) — a message carries a module whole (base64), so 64 MiB. */
+export const MAX_LINE = 64 << 20;
+/** A request line, checked. */
+function requestOf(line) {
+    let r;
+    try {
+        r = JSON.parse(line);
+    }
+    catch {
+        throw new Error("not JSON");
+    }
+    const o = r;
+    if (o && typeof o === "object" && o.op === "message") {
+        if (typeof o.handle !== "string" || !o.handle)
+            throw new Error("a message names its instance (handle)");
+        if (typeof o.message !== "string" || typeof o.body !== "string")
+            throw new Error("a message is {message, body}, each base64");
+        return o;
+    }
+    if (o && typeof o === "object" && o.op === "reclaim") {
+        if (typeof o.handle !== "string" || !o.handle)
+            throw new Error("a reclaim names its instance (handle)");
+        return o;
+    }
+    if (!o || typeof o !== "object" || o.op !== "event")
+        throw new Error("want {op: \"event\", handle, box, event}, {op: \"reclaim\", handle} or {op: \"message\", handle, message, body}");
+    if (typeof o.handle !== "string" || !o.handle || typeof o.box !== "string" || !o.box)
+        throw new Error("an event names its instance (handle) and its box");
+    if (!o.event || typeof o.event !== "object" || Array.isArray(o.event))
+        throw new Error("the event is a JSON object");
+    return o;
+}
+/**
+ * Listen on `path`: a socket left by a router that is gone is replaced; one
+ * that answers is another router's, and this one refuses to start on it.
+ */
+export async function listenControl(path, h) {
+    if (existsSync(path)) {
+        if (await answers(path))
+            throw new Error(`${path}: another router answers on it`);
+        unlinkSync(path);
+    }
+    const server = createServer((s) => serveOne(s, h));
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(path, () => { server.off("error", reject); resolve(); });
+    });
+    chmodSync(path, 0o600);
+    return server;
+}
+/** Close the socket and remove its file. */
+export async function closeControl(server, path) {
+    await new Promise((r) => server.close(() => r()));
+    try {
+        unlinkSync(path);
+    }
+    catch { /* gone already */ }
+}
+function serveOne(s, h) {
+    let buf = "";
+    let done = false;
+    const reply = (a) => { if (done)
+        return; done = true; s.end(`${JSON.stringify(a)}\n`); };
+    s.setEncoding("utf8");
+    s.on("error", () => { });
+    s.on("data", (d) => {
+        if (done)
+            return;
+        buf += d;
+        const nl = buf.indexOf("\n");
+        if (nl < 0) {
+            if (buf.length > MAX_LINE)
+                reply({ ok: false, error: "request too long" });
+            return;
+        }
+        let req;
+        try {
+            req = requestOf(buf.slice(0, nl));
+        }
+        catch (e) {
+            reply({ ok: false, error: e.message });
+            return;
+        }
+        if (req.op === "message") {
+            if (!h.message) {
+                reply({ ok: false, error: "this router takes no messages here" });
+                return;
+            }
+            h.message(req.handle, Buffer.from(req.message, "base64"), Buffer.from(req.body, "base64")).then((entry) => reply({ ok: true, entry }), (e) => reply({ ok: false, error: e.message }));
+            return;
+        }
+        if (req.op === "reclaim") {
+            if (!h.reclaim) {
+                reply({ ok: false, error: "this router reclaims nothing" });
+                return;
+            }
+            h.reclaim(req.handle).then(() => reply({ ok: true, entry: "" }), (e) => reply({ ok: false, error: e.message }));
+            return;
+        }
+        h.event(req.handle, req.box, req.event).then((entry) => reply({ ok: true, entry }), (e) => reply({ ok: false, error: e.message }));
+    });
+}
+/** Whether something answers on the socket at `path` (connects). */
+function answers(path) {
+    return new Promise((resolve) => {
+        const c = createConnection(path);
+        c.once("connect", () => { c.destroy(); resolve(true); });
+        c.once("error", () => resolve(false));
+    });
+}
+/**
+ * Send one request to the router on `path`. Undefined if no router answers
+ * there (no socket, or one left by a router that is gone); its answer otherwise.
+ */
+export function controlRequest(path, req, timeoutMs = 60_000) {
+    if (!existsSync(path))
+        return Promise.resolve(undefined);
+    return new Promise((resolve, reject) => {
+        const c = createConnection(path);
+        let buf = "";
+        let connected = false;
+        const t = setTimeout(() => { c.destroy(); reject(new Error(`${path}: no answer in ${timeoutMs} ms`)); }, timeoutMs);
+        c.setEncoding("utf8");
+        c.once("connect", () => { connected = true; c.write(`${JSON.stringify(req)}\n`); });
+        c.on("data", (d) => { buf += d; });
+        c.once("end", () => {
+            clearTimeout(t);
+            try {
+                resolve(JSON.parse(buf.split("\n")[0]));
+            }
+            catch {
+                reject(new Error(`${path}: a malformed answer`));
+            }
+        });
+        c.once("error", (e) => {
+            clearTimeout(t);
+            // Not there, or nobody listening: no router answers on it.
+            if (!connected)
+                resolve(undefined);
+            else
+                reject(e);
+        });
+    });
+}

package/dist/host/cron.d.ts

@@ -0,0 +1,99 @@
+/** A tick request's schedule: every `every` ms, or once at `at`, into `box`. */
+export interface TickSpec {
+    every?: number;
+    at?: number;
+    box: string;
+    body?: Record<string, unknown>;
+}
+/** One schedule: whose (the instance the ticks go to, its key), its name and spec, the request that made it, the next tick. */
+export interface Schedule extends TickSpec {
+    instance: string;
+    recipient: string;
+    name: string;
+    request: string;
+    next: number;
+}
+/** A request the cron provider takes (box `cron`), checked; an error's text otherwise. */
+export type CronRequest = {
+    fn: "tick";
+    name: string;
+    spec: TickSpec;
+} | {
+    fn: "stop";
+    name: string;
+};
+export declare const CRON_SHAPE = "the cron provider takes {fn: \"tick\", every: <ms> | at: <ms since the epoch>, box, body?: {\u2026}, name} or {fn: \"stop\", name} in box \"cron\"";
+/** A body as the cron provider reads it. */
+export declare function cronRequestOf(b: unknown): CronRequest | string;
+/** A tick's body. */
+export declare function tickBody(s: Pick<Schedule, "name" | "body">, due: number): Record<string, unknown>;
+/** Where schedules are kept (the reference host: host.db; a test or a remote service: memory). */
+export interface ScheduleStore {
+    all(): Schedule[];
+    save(s: Schedule): void;
+    drop(instance: string, name: string): void;
+}
+/** A store in memory. */
+export declare function memorySchedules(): ScheduleStore;
+/** host.db's `cron_schedule` as a ScheduleStore (the spec as dag-cbor). */
+export declare function dbSchedules(db: {
+    saveSchedule(s: {
+        instance: string;
+        name: string;
+        recipient: string;
+        spec: Uint8Array;
+        request: string;
+        next: number;
+    }): void;
+    dropSchedule(instance: string, name: string): boolean;
+    schedules(): Array<{
+        instance: string;
+        name: string;
+        recipient: string;
+        spec: Uint8Array;
+        request: string;
+        next: number;
+    }>;
+}): ScheduleStore;
+export interface CronOptions {
+    /** The clock (ms). */
+    now(): number;
+    /** Send one tick: a signed message from the provider to `s.recipient` in `s.box`. Throws if it could not go (an `at` tick is tried again). */
+    tick(s: Schedule, body: Record<string, unknown>): Promise<void>;
+    /** Whether the instance should be woken for a tick (the reference host: running, or something in it subscribes the box); default yes. */
+    wake?(s: Schedule): Promise<boolean>;
+    /** Where the schedules are kept (default memory). */
+    store?: ScheduleStore;
+    log?(source: string, line: string): void;
+    /** An `at` tick that could not go is tried again this much later (ms; default 60 000). */
+    retryMs?: number;
+}
+export declare class Cron {
+    readonly o: CronOptions;
+    private readonly store;
+    private timer?;
+    private ticking;
+    private stopped;
+    /** Whether this one sends ticks (start): a schedule asked of one that does not is kept for one that does. */
+    private started;
+    constructor(o: CronOptions);
+    private say;
+    /** Take up the kept schedules (a host start): each `every` one ticks once now (late), each `at` one at its time. */
+    start(): void;
+    /**
+     * A request from `instance` (whose key is `recipient`), the message
+     * `request`: → the answer body (beside `replyTo`). A tick request replaces
+     * the schedule of its name; stop ends it.
+     */
+    request(instance: string, recipient: string, request: string, body: unknown): Record<string, unknown>;
+    /** `instance`'s schedules and when each ticks next (the host page, tests). */
+    of(instance: string): Schedule[];
+    /** Drop every schedule of an instance that is gone. */
+    forget(instance: string): void;
+    /** Send every tick that is due (one pass at a time); then wait for the next. */
+    tick(): Promise<void>;
+    /** No more ticks; resolves once a pass under way has finished. */
+    stop(): Promise<void>;
+    private schedule;
+    private fire;
+}

package/dist/host/cron.js

@@ -0,0 +1,196 @@
+// The cron provider (#69): scheduling is a message to a provider. A program
+// that wants to be ticked emits, to the cron provider's key (#126: the
+// address book's entry reached at `local` `cron`, or a key its owner gives
+// it), box `cron`:
+//
+//   {fn: "tick", every: <ms> | at: <ms since the epoch>, box, body?: {…}, name}
+//   {fn: "stop", name}
+//
+// and the provider answers it ({replyTo, name, next: <ms>} | {replyTo, name,
+// stopped: true | false} | {replyTo, error}), then sends each tick as a signed
+// message from its own identity into the named box of the instance that
+// asked:
+//
+//   {...body, kind: body.kind ?? "cron", name, due: <ms>}
+//
+// routed there by the instance's subscription to that box (sender the cron
+// provider, or anyone). `due` is when the tick was scheduled; the message's
+// entry stamp is when it arrived. A tick request replaces the instance's
+// schedule of the same name; `stop` ends it. An `every` schedule ticks at
+// once, then every `every` ms on that grid; a tick the provider was too
+// late for is not made up (one tick, then the next grid point after now). An
+// `at` schedule ticks once — at `at`, or at once if that is past — and is
+// then gone. The schedules are the provider's state, kept across restarts
+// (the reference host: host.db `cron_schedule`); at a host start every
+// `every` schedule ticks once (a restart is a late tick), each `at` one at
+// its time.
+//
+// This module is the schedule itself (`Cron`): the provider on the reference
+// host (providers.ts, its ticks appended as `local` requests) and a remote
+// cron service (src/peers/cron.ts, its ticks delivered to the instance's
+// messagebox over BRC-103/104) both run it. Which one an instance talks to
+// is its address book's business: the same key, `local` or `mailbox`.
+import * as dagCbor from "@ipld/dag-cbor";
+export const CRON_SHAPE = "the cron provider takes {fn: \"tick\", every: <ms> | at: <ms since the epoch>, box, body?: {…}, name} or {fn: \"stop\", name} in box \"cron\"";
+/** A body as the cron provider reads it. */
+export function cronRequestOf(b) {
+    const o = b;
+    if (!o || typeof o !== "object" || Array.isArray(o) || o instanceof Uint8Array)
+        return CRON_SHAPE;
+    if (typeof o.name !== "string" || !o.name)
+        return `${CRON_SHAPE}: a request names its schedule (name)`;
+    if (o.fn === "stop")
+        return { fn: "stop", name: o.name };
+    if (o.fn !== "tick")
+        return CRON_SHAPE;
+    if (typeof o.box !== "string" || !o.box || o.box.startsWith(":"))
+        return `${CRON_SHAPE}: box is a box name (not empty, not reserved)`;
+    if ((o.every === undefined) === (o.at === undefined))
+        return `${CRON_SHAPE}: one of every and at`;
+    if (o.every !== undefined && !(Number.isSafeInteger(o.every) && o.every > 0))
+        return `${CRON_SHAPE}: every is a positive whole number of ms`;
+    if (o.at !== undefined && !(Number.isSafeInteger(o.at) && o.at >= 0))
+        return `${CRON_SHAPE}: at is a whole number of ms since the epoch`;
+    if (o.body !== undefined && (!o.body || typeof o.body !== "object" || Array.isArray(o.body) || o.body instanceof Uint8Array))
+        return `${CRON_SHAPE}: body is a map`;
+    return { fn: "tick", name: o.name, spec: { box: o.box, ...(o.every !== undefined ? { every: o.every } : { at: o.at }), ...(o.body !== undefined ? { body: o.body } : {}) } };
+}
+/** A tick's body. */
+export function tickBody(s, due) {
+    const body = s.body ?? {};
+    return { ...body, kind: body.kind ?? "cron", name: s.name, due };
+}
+/** How a schedule is described in log lines. */
+const label = (s) => `${s.name} (${s.box} ${s.every !== undefined ? `every ${s.every} ms` : `at ${new Date(s.at).toISOString()}`})`;
+/** A store in memory. */
+export function memorySchedules() {
+    const m = new Map();
+    return {
+        all: () => [...m.values()],
+        save: (s) => { m.set(`${s.instance}\0${s.name}`, { ...s }); },
+        drop: (i, n) => { m.delete(`${i}\0${n}`); },
+    };
+}
+/** host.db's `cron_schedule` as a ScheduleStore (the spec as dag-cbor). */
+export function dbSchedules(db) {
+    return {
+        all: () => db.schedules().map((r) => ({ instance: r.instance, name: r.name, recipient: r.recipient, request: r.request, next: r.next, ...dagCbor.decode(r.spec) })),
+        save: (s) => db.saveSchedule({ instance: s.instance, name: s.name, recipient: s.recipient, request: s.request, next: s.next, spec: dagCbor.encode({ box: s.box, ...(s.every !== undefined ? { every: s.every } : { at: s.at }), ...(s.body !== undefined ? { body: s.body } : {}) }) }),
+        drop: (i, n) => { db.dropSchedule(i, n); },
+    };
+}
+/** setTimeout's longest delay; a tick further off is looked at again then. */
+const MAX_DELAY = 2 ** 31 - 1;
+export class Cron {
+    o;
+    store;
+    timer;
+    ticking = Promise.resolve();
+    stopped = false;
+    /** Whether this one sends ticks (start): a schedule asked of one that does not is kept for one that does. */
+    started = false;
+    constructor(o) {
+        this.o = o;
+        this.store = o.store ?? memorySchedules();
+    }
+    say(source, line) { this.o.log?.(source, line); }
+    /** Take up the kept schedules (a host start): each `every` one ticks once now (late), each `at` one at its time. */
+    start() {
+        this.started = true;
+        const now = this.o.now();
+        for (const s of this.store.all())
+            if (s.every !== undefined && s.next > now)
+                this.store.save({ ...s, next: now });
+        this.schedule();
+    }
+    /**
+     * A request from `instance` (whose key is `recipient`), the message
+     * `request`: → the answer body (beside `replyTo`). A tick request replaces
+     * the schedule of its name; stop ends it.
+     */
+    request(instance, recipient, request, body) {
+        if (this.stopped)
+            return { error: "the cron provider is stopping" };
+        const r = cronRequestOf(body);
+        if (typeof r === "string")
+            return { error: r };
+        if (r.fn === "stop") {
+            const had = this.store.all().some((s) => s.instance === instance && s.name === r.name);
+            this.store.drop(instance, r.name);
+            this.say(instance, `cron: ${r.name} stopped${had ? "" : " (it was not scheduled)"}`);
+            this.schedule();
+            return { name: r.name, stopped: had };
+        }
+        const next = r.spec.at !== undefined ? r.spec.at : this.o.now();
+        const s = { instance, recipient, name: r.name, request, next, ...r.spec };
+        this.store.save(s);
+        this.say(instance, `cron: ${label(s)} scheduled, next ${new Date(next).toISOString()}`);
+        this.schedule();
+        return { name: r.name, next };
+    }
+    /** `instance`'s schedules and when each ticks next (the host page, tests). */
+    of(instance) {
+        return this.store.all().filter((s) => s.instance === instance);
+    }
+    /** Drop every schedule of an instance that is gone. */
+    forget(instance) {
+        for (const s of this.of(instance))
+            this.store.drop(instance, s.name);
+        this.schedule();
+    }
+    /** Send every tick that is due (one pass at a time); then wait for the next. */
+    tick() {
+        this.ticking = this.ticking.then(() => this.fire()).catch((e) => this.say("router", `cron: ${e.message}`));
+        return this.ticking;
+    }
+    /** No more ticks; resolves once a pass under way has finished. */
+    async stop() {
+        this.stopped = true;
+        clearTimeout(this.timer);
+        this.timer = undefined;
+        await this.ticking;
+    }
+    schedule() {
+        clearTimeout(this.timer);
+        this.timer = undefined;
+        if (this.stopped || !this.started)
+            return;
+        let next = Infinity;
+        for (const s of this.store.all())
+            next = Math.min(next, s.next);
+        if (next === Infinity)
+            return;
+        this.timer = setTimeout(() => void this.tick(), Math.min(MAX_DELAY, Math.max(0, next - this.o.now()) + 1));
+    }
+    async fire() {
+        if (this.stopped)
+            return;
+        for (const s of this.store.all()) {
+            if (this.stopped)
+                return;
+            const now = this.o.now();
+            if (s.next > now)
+                continue;
+            const due = s.next;
+            // The next tick first: the grid point after now (one tick however late this one is); an `at` one is done.
+            if (s.every !== undefined)
+                this.store.save({ ...s, next: due + (Math.floor((now - due) / s.every) + 1) * s.every });
+            else
+                this.store.drop(s.instance, s.name);
+            if (this.o.wake && !(await this.o.wake(s).catch((e) => { this.say(s.instance, `cron: ${label(s)}: the instance could not be woken: ${e.message}`); return false; }))) {
+                this.say(s.instance, `cron: ${label(s)} due: stopped, and nothing in it subscribes ${s.box}: not woken`);
+                continue;
+            }
+            try {
+                await this.o.tick(s, tickBody(s, due));
+                this.say(s.instance, `cron: ${label(s)} → ${s.box}`);
+            }
+            catch (e) {
+                this.say(s.instance, `cron: ${label(s)}: not sent: ${e.message}`);
+                if (s.at !== undefined && !this.stopped)
+                    this.store.save({ ...s, next: now + (this.o.retryMs ?? 60_000) });
+            }
+        }
+        this.schedule();
+    }
+}

package/dist/host/deliver.d.ts

@@ -0,0 +1,53 @@
+import type { WalletInterface } from "@bsv/sdk";
+import type { CID } from "multiformats/cid";
+import type { HttpRequest, HttpResponse, MailRecord } from "./providers.ts";
+export declare const AUTH_PROTOCOL: [2, string];
+/** The `deliver` event a step records (#157). */
+export interface DeliverEvent {
+    kind: "event";
+    event: "deliver";
+    transport: string;
+    url: string;
+    message: CID;
+    nonce: Uint8Array;
+    app?: string;
+}
+/** The answer the instance admits (box `deliver`). */
+export interface DeliveryAnswer {
+    kind: "delivery";
+    replyTo: CID;
+    peer: Uint8Array;
+    nonce: string;
+    yourNonce: string;
+    signature: Uint8Array;
+    status: number;
+    headers?: Record<string, string>;
+    body: Uint8Array;
+    [k: string]: unknown;
+}
+/** The payload a request signs (authfetch.zig requestPayload). */
+export declare function requestPayload(rid: Uint8Array, method: string, path: string, query: string, headers: Record<string, string>, body: Uint8Array): Uint8Array;
+/** The answer's signed headers: x-bsv-* but x-bsv-auth-*, and authorization; lower-cased. */
+export declare function signedResponseHeaders(h: Record<string, string>): Record<string, string>;
+/** The payload a response signs (authfetch.zig responsePayload): request id, status, the signed headers sorted, the body. */
+export declare function responsePayload(rid: Uint8Array, status: number, headers: Record<string, string>, body: Uint8Array): Uint8Array;
+export interface DelivererOptions {
+    /** One HTTP exchange (the router's: this host's own URLs in process). */
+    http(req: HttpRequest, from: string): Promise<HttpResponse>;
+    log?(source: string, line: string): void;
+}
+export declare class Deliverer {
+    readonly o: DelivererOptions;
+    /** BRC-103 sessions, per instance and server base URL, in memory. */
+    private sessions;
+    constructor(o: DelivererOptions);
+    /**
+     * Carry one `deliver` event for instance `handle` (its wallet: the instance's key), its mail record
+     * and the body's dag-cbor bytes: the answer to admit, or undefined (no answer that stands).
+     */
+    carry(handle: string, wallet: WalletInterface, eventCid: CID, ev: DeliverEvent, mail: MailRecord, body: Uint8Array): Promise<DeliveryAnswer | undefined>;
+    /** BRC-103: our nonce to <base>/.well-known/auth; the answer's signature over both nonces checked. */
+    private handshake;
+    /** BRC-104: the request signed on the session (request id and nonce = the event's nonce). Undefined: no answer. */
+    private send;
+}