@dcasegr/skein 0.2.9 → 0.3.3

package/dist/host/p2p.d.ts

@@ -388,6 +388,23 @@ export declare class P2PHost {
      * frame written, one frame read back, the stream closed. → the answer's bytes.
      */
     request(handle: string, peer: string, protocol: string, body: Uint8Array, timeoutMs?: number): Promise<Uint8Array>;
+    /**
+     * One request to a peer and its answer, for host code (the open-exchange host's swap relay,
+     * 2026-11-06): from `handle`'s node, a connection to `peer` (a peer ID, or a multiaddr with
+     * /p2p/<id>), a stream on `protocol`, ONE frame written, ONE frame read back, the stream closed →
+     * the answer's bytes and the peer the connection proved (Noise: its peer ID's multihash). Nothing
+     * is logged anywhere. No timer of its own: the stream is live until the peer answers or the
+     * connection breaks. A break throws, its message saying which: the dial refused, the protocol not
+     * served, the write failed, the stream closed without an answer. `signal` is the caller's only
+     * bound: once it fires, a dial in progress is cancelled, a request not yet written is never
+     * written, an open stream is closed, and the call throws "the call was cancelled".
+     */
+    call(handle: string, peer: string, protocol: string, body: Uint8Array, o?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        from: Uint8Array;
+        body: Uint8Array;
+    }>;
     /** The protocols `handle`'s node handles inbound now (the libp2p node's own registry: its rows', the host's, /skein/message/1.0.0). */
     handledProtocols(handle: string): string[];
     /** The addresses `handle`'s node knows for `peer` (its peer store), as multiaddr strings. */

package/dist/host/p2p.js

@@ -1082,6 +1082,49 @@ export class P2PHost {
             throw e;
         }
     }
+    /**
+     * One request to a peer and its answer, for host code (the open-exchange host's swap relay,
+     * 2026-11-06): from `handle`'s node, a connection to `peer` (a peer ID, or a multiaddr with
+     * /p2p/<id>), a stream on `protocol`, ONE frame written, ONE frame read back, the stream closed →
+     * the answer's bytes and the peer the connection proved (Noise: its peer ID's multihash). Nothing
+     * is logged anywhere. No timer of its own: the stream is live until the peer answers or the
+     * connection breaks. A break throws, its message saying which: the dial refused, the protocol not
+     * served, the write failed, the stream closed without an answer. `signal` is the caller's only
+     * bound: once it fires, a dial in progress is cancelled, a request not yet written is never
+     * written, an open stream is closed, and the call throws "the call was cancelled".
+     */
+    async call(handle, peer, protocol, body, o = {}) {
+        const n = this.nodeOf(handle);
+        const signal = o.signal;
+        const cancelled = () => new Error(`the call was cancelled${signal?.reason instanceof Error ? `: ${signal.reason.message}` : typeof signal?.reason === "string" ? `: ${signal.reason}` : ""}`);
+        if (signal?.aborted)
+            throw cancelled();
+        let target;
+        try {
+            target = peer.startsWith("/") ? multiaddr(peer) : peerIdFromString(peer);
+        }
+        catch (e) {
+            throw new Error(`not a peer: ${peer}: ${e.message}`);
+        }
+        const conn = await n.node.dial(target, signal ? { signal } : {}).catch((e) => { throw signal?.aborted ? cancelled() : new Error(`the dial was refused: ${e.message}`); });
+        if (signal?.aborted)
+            throw cancelled();
+        const stream = await conn.newStream(protocol, signal ? { signal } : {}).catch((e) => { throw signal?.aborted ? cancelled() : new Error(`the peer does not serve ${protocol}: ${e.message}`); });
+        const lp = lpStream(stream);
+        try {
+            // Never written once the signal has fired.
+            if (signal?.aborted)
+                throw cancelled();
+            await lp.write(body, signal ? { signal } : {}).catch((e) => { throw signal?.aborted ? cancelled() : new Error(`the write failed: ${e.message}`); });
+            const answer = await lp.read(signal ? { signal } : {}).catch((e) => { throw signal?.aborted ? cancelled() : new Error(`the stream closed without an answer: ${e.message}`); });
+            await stream.close().catch(() => { });
+            return { from: conn.remotePeer.toMultihash().bytes, body: answer.subarray() };
+        }
+        catch (e) {
+            stream.abort(e);
+            throw e;
+        }
+    }
     /** The protocols `handle`'s node handles inbound now (the libp2p node's own registry: its rows', the host's, /skein/message/1.0.0). */
     handledProtocols(handle) { return this.byHandle.get(handle)?.node.getProtocols() ?? []; }
     /** The addresses `handle`'s node knows for `peer` (its peer store), as multiaddr strings. */

package/dist/host/router.d.ts

@@ -172,7 +172,8 @@ export interface RouterOptions {
      */
     appEvent?(handle: string, record: Record<string, unknown>): void;
     /**
-     * An application host's reads (shruggr/open-exchange 0.11.0, the public read API): a GET for an
+     * An application host's requests (shruggr/open-exchange 0.11.0, the public read API; every method
+     * since 0.3.2, so the hook checks `req.method` itself): a request for an
      * instance (its hostname, `/@<handle>/`, or the root instance's hostname), asked AFTER the host's own
      * reads there (the instance card, `/<app>/.live/<topic>`) and BEFORE the request is forwarded to the
      * instance's program. `route` is the path at the instance (`/amm/pools`); `undefined`: not the host's,
@@ -205,8 +206,13 @@ export interface RouterRequest {
     method: string;
     url: string;
     headers: Record<string, string>;
-    body: Uint8Array; /** The instance whose `http` this is (none for a socket's). */
-    from?: string;
+    body: Uint8Array;
+    /** The instance whose `http` this is (none for a socket's). */ from?: string;
+    /**
+     * 0.3.2: on a socket's request (Router.handler), aborted when the client's connection closes
+     * before the answer is written; never fired after the answer. In process: none.
+     */
+    signal?: AbortSignal;
 }
 export interface RouterResponse {
     status: number;
@@ -416,6 +422,24 @@ export declare class Router {
     messageLocal(handle: string, messageBytes: Uint8Array, body: Uint8Array): Promise<CID>;
     /** Sign `data` with `handle`'s signer: [2, "metanet handles envelope"] / `send` / anyone — an intention request's signature (providers.ts), a beacon's beat (p2p.ts beaconFrame). */
     private signAs;
+    /**
+     * A BRC-169 message signed by `handle`'s key through this host's key holder, outside any step (as
+     * the host signs an intention's request, providers.ts): the mail record {kind: "mail", op: "put",
+     * sender: the instance's identity, recipient?, box, body: <the body's CID>, nonce, signature}
+     * ([2, "metanet handles envelope"], key "send", counterparty anyone, over the record's dag-cbor
+     * without `signature`) and the body's dag-cbor bytes. `recipient` an identity key (33 bytes or
+     * hex); `nonce` 16 bytes, fresh when absent. For host code (the open-exchange host's swap relay
+     * signs its package to a validator with the token instance's key, 2026-11-06). Nothing is logged.
+     */
+    signMessage(handle: string, m: {
+        recipient?: Uint8Array | string;
+        box: string;
+        body: Uint8Array;
+        nonce?: Uint8Array;
+    }): Promise<{
+        message: MailRecord;
+        body: Uint8Array;
+    }>;
     /**
      * An inbound libp2p message or stream frame (#51, #68): appended as
      * received (the message with its signature; the frame), and the verdict
@@ -423,7 +447,9 @@ export declare class Router {
      * on, once it comes to rest (#66). The front door verifies, routes, and
      * admits what an accept carries (the message's `p2p` event first); a
      * redelivered message it accepted before is `ignore`. Its thread failing,
-     * or not answering within the wait, is `ignore` (no penalty). A frame a
+     * or (a topic message) not answering within the wait, is `ignore` (no
+     * penalty); a stream frame's answer is waited for until its thread rests,
+     * however long (the stream stays open; nothing late is dropped). A frame a
      * route's filter answers at the door (a read, #143: nothing written) is
      * answered with the filter's body (#154: the overlay's sync protocol).
      */

package/dist/host/router.js

@@ -113,6 +113,8 @@ import { createServer } from "node:http";
 import { join } from "node:path";
 import { KeyDeriver, P2PKH, PrivateKey, ProtoWallet, Transaction } from "@bsv/sdk";
 import * as dagCbor from "@ipld/dag-cbor";
+import { randomBytes } from "node:crypto";
+import { encode as encodeBlock } from "../runtime/cid.js";
 import { CID } from "multiformats/cid";
 import { rootIdentity } from "../runtime/identity.js";
 import { DEFAULTS, short, stampMs } from "../runtime/log.js";
@@ -749,6 +751,38 @@ export class Router {
         const { signature } = await (await this.o.walletFor(row)).createSignature({ protocolID: MESSAGE_PROTOCOL, keyID: MESSAGE_KEY_ID, counterparty: "anyone", data: [...data] });
         return Uint8Array.from(signature);
     }
+    /**
+     * A BRC-169 message signed by `handle`'s key through this host's key holder, outside any step (as
+     * the host signs an intention's request, providers.ts): the mail record {kind: "mail", op: "put",
+     * sender: the instance's identity, recipient?, box, body: <the body's CID>, nonce, signature}
+     * ([2, "metanet handles envelope"], key "send", counterparty anyone, over the record's dag-cbor
+     * without `signature`) and the body's dag-cbor bytes. `recipient` an identity key (33 bytes or
+     * hex); `nonce` 16 bytes, fresh when absent. For host code (the open-exchange host's swap relay
+     * signs its package to a validator with the token instance's key, 2026-11-06). Nothing is logged.
+     */
+    async signMessage(handle, m) {
+        const id = this.o.db.get(handle)?.identity;
+        if (!id)
+            throw new Error(`no instance ${handle} with an identity here`);
+        let value;
+        try {
+            value = dagCbor.decode(m.body);
+        }
+        catch {
+            throw new Error("the body is not dag-cbor");
+        }
+        const block = encodeBlock(value);
+        if (Buffer.compare(Buffer.from(block.bytes), Buffer.from(m.body)) !== 0)
+            throw new Error("the body is not canonical dag-cbor");
+        if (m.nonce && m.nonce.length !== 16)
+            throw new Error("nonce: want 16 bytes");
+        const recipient = m.recipient === undefined ? undefined : typeof m.recipient === "string" ? keyBytes(m.recipient) : m.recipient;
+        const unsigned = {
+            kind: "mail", op: "put", sender: keyBytes(id), ...(recipient ? { recipient } : {}),
+            box: m.box, body: block.cid, nonce: m.nonce ?? Uint8Array.from(randomBytes(16)),
+        };
+        return { message: { ...unsigned, signature: await this.signAs(handle, dagCbor.encode(unsigned)) }, body: m.body };
+    }
     /**
      * An inbound libp2p message or stream frame (#51, #68): appended as
      * received (the message with its signature; the frame), and the verdict
@@ -756,7 +790,9 @@ export class Router {
      * on, once it comes to rest (#66). The front door verifies, routes, and
      * admits what an accept carries (the message's `p2p` event first); a
      * redelivered message it accepted before is `ignore`. Its thread failing,
-     * or not answering within the wait, is `ignore` (no penalty). A frame a
+     * or (a topic message) not answering within the wait, is `ignore` (no
+     * penalty); a stream frame's answer is waited for until its thread rests,
+     * however long (the stream stays open; nothing late is dropped). A frame a
      * route's filter answers at the door (a read, #143: nothing written) is
      * answered with the filter's body (#154: the overlay's sync protocol).
      */
@@ -802,7 +838,12 @@ export class Router {
             this.say(handle, `${source} from ${from}: ${verdict} (turned away at the door: ${reason})`);
             return { verdict, reason };
         }
-        const a = await l.kernel.answer(entry, this.o.answerWaitMs ?? ANSWER_WAIT_MS);
+        let a = await l.kernel.answer(entry, this.o.answerWaitMs ?? ANSWER_WAIT_MS);
+        // A stream frame's answer is written whenever its thread rests (the swap relay's call, 2026-11-06):
+        // the stream is open the whole time, so the wait is waited again, never answered "ignore" and the
+        // late answer dropped. A topic message keeps the bound (GossipSub waits on its verdict).
+        while (call.topic === undefined && a.state !== "finished" && a.state !== "errored" && !this.stopped)
+            a = await (await this.hydrate(handle)).kernel.answer(entry, this.o.answerWaitMs ?? ANSWER_WAIT_MS);
         this.settle(l);
         if (a.state !== "finished") {
             const why = a.state === "errored" ? `the front door failed: ${a.error}` : `not answered in time (${a.state})`;
@@ -2235,8 +2276,8 @@ export class Router {
             // #148: a stream, served on a socket only (handler).
             if (req.method === "GET" && EVENTS_ROUTE.test(x.route))
                 return json(400, { status: "error", code: "ERR_BAD_REQUEST", description: "an event stream (text/event-stream) is served on a connection of its own, not in process" });
-            // An application host's own reads (appRead): before the instance's program; undefined falls through.
-            if (req.method === "GET" && this.o.appRead) {
+            // An application host's own requests (appRead, every method since 0.3.2): before the instance's program; undefined falls through.
+            if (this.o.appRead) {
                 const a = await this.o.appRead(x.handle, x.route, url, req);
                 if (a)
                     return a;
@@ -2489,11 +2530,16 @@ export class Router {
                     return;
                 }
             }
+            // 0.3.2: the client's connection closing before the answer is written (the response's `close`
+            // with nothing ended: the request's own `close` also fires once its body is read) aborts req.signal.
+            const gone = new AbortController();
+            res.on("close", () => { if (!res.writableEnded)
+                gone.abort(new Error("the client closed the connection")); });
             const chunks = [];
             req.on("data", (c) => chunks.push(c));
             req.on("end", () => {
                 const url = `http://${req.headers.host ?? `127.0.0.1:${this.port}`}${req.url ?? "/"}`;
-                this.dispatch({ method: req.method ?? "GET", url, headers: headerMap(req.headers), body: new Uint8Array(Buffer.concat(chunks)) })
+                this.dispatch({ method: req.method ?? "GET", url, headers: headerMap(req.headers), body: new Uint8Array(Buffer.concat(chunks)), signal: gone.signal })
                     .then((r) => {
                     if (!r.stream) {
                         res.writeHead(r.status, { ...cors, ...r.headers, "content-length": String(r.body.length) });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcasegr/skein",
-  "version": "0.2.9",
+  "version": "0.3.3",
   "description": "A deterministic WASI machine over a content-addressed graph: the node host (it loads the wasm kernel, kernel-zig built for the web target), the client, its peers, and dev tools.",
   "type": "module",
   "bin": {