@dcasegr/skein 0.1.1 → 0.2.8

package/dist/host/p2p.js

@@ -16,8 +16,9 @@
 //              compressed key), so the key reads straight out of the peer ID.
 //   node       GossipSub (StrictSign: every message is signed by its publisher's
 //              peer key), noise + yamux, TCP and WebSocket listeners (WSS with a
-//              certificate), Kademlia DHT off | client | server, mDNS on/off,
-//              bootstrap peers kept connected, circuit relays.
+//              certificate), Kademlia DHT off | auto | client | server, AutoNAT,
+//              UPnP/NAT-PMP port mapping, mDNS on/off, bootstrap peers kept
+//              connected, circuit relays.
 //   topics     the instance's `libp2p.topics`, its dispatch table's libp2p
 //              rows' topics (libp2pConfig) and the topics its apps subscribed
 //              (#119: `subscribe {topic, program, fn}` / `unsubscribe {topic}`,
@@ -53,10 +54,31 @@
 //              read from a dialled stream handed back (`frames`) to become a
 //              message to the instance — the next frame arrives as an entry.
 //
+// The host node (#156, one node): the node of the HOST key (hostKey: on a one-key host the key
+// every instance's node uses, so the instances join it) runs whether or not an instance declares
+// libp2p — the Teranode headers tracker rides it (teranode.ts: the block topic subscribed as a host
+// topic, hostTopic, judged by the tracker, never the front door). Every node carries ONE Kademlia
+// DHT, ours: `skeinDht` on `/skein/kad/<network>/1.0.0` for the overlay's topics (discover()
+// provides and finds on it). There is no Teranode DHT (2026-11-02, plans/teranode-dht-off-2026-11-02.md):
+// the tracker's block-topic peers come from its bootstrap list (SKEIN_TERANODE_BOOTSTRAP, the
+// network's defaults unioned) and GossipSub. Teranode's DHT is the public IPFS DHT; even a kad client
+// crawls it and fills a js-libp2p node's connection cap, which then refuses every newcomer.
+//
 // Host-wide settings (hostP2PConfig): SKEIN_LIBP2P_LISTEN, _BOOTSTRAP, _RELAYS
-// (comma-separated multiaddrs), _DHT (off | client | server), _MDNS (on | off),
-// _TLS_CERT / _TLS_KEY (PEM files: the WebSocket listener serves TLS, so
-// browsers can dial /tls/ws); from the environment, else $SKEIN_HOME/host.env.
+// (comma-separated multiaddrs), _DHT (off | auto | client | server, default auto: the skein DHT's mode), _UPNP
+// (on | off, default on), _MDNS (on | off), _TLS_CERT / _TLS_KEY (PEM files: the WebSocket listener
+// serves TLS, so browsers can dial /tls/ws); from the environment, else $SKEIN_HOME/host.env.
+//
+// The defaults are tuned for discovery (2026-11-01, plans/open-defaults-2026-11-01.md): TCP on every
+// interface, IPv4 and IPv6, on ONE fixed port (DEFAULT_PORT, the same on every install, so a user who
+// opens one port knows which; taken at start: one line, and an OS-chosen port on the same interfaces);
+// the WebSocket listener stays on loopback (plain WS off loopback is dev only). DHT (the skein DHT) `auto` = kad-DHT's
+// own switch (clientMode left unset: a client until the node has a confirmed public address, then a
+// server, and back) with AutoNAT confirming addresses; `client` = only ever a client; `server` = a
+// server from the start (a hosted node behind a known-open port need not wait for AutoNAT). UPnP asks
+// the router to map the port where it allows it (a router that refuses or none found: a line, nothing
+// else); its mapped address is confirmed by AutoNAT before it is announced, so AutoNAT runs whenever
+// UPnP is on or the DHT is auto or server.
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { noise } from "@chainsafe/libp2p-noise";
@@ -65,14 +87,18 @@ import { circuitRelayTransport } from "@libp2p/circuit-relay-v2";
 import { privateKeyFromRaw } from "@libp2p/crypto/keys";
 import { gossipsub, TopicValidatorResult } from "@libp2p/gossipsub";
 import { identify } from "@libp2p/identify";
+import { autoNAT } from "@libp2p/autonat";
 import { kadDHT, passthroughMapper, removePrivateAddressesMapper } from "@libp2p/kad-dht";
+import { defaultLogger } from "@libp2p/logger";
 import { mdns } from "@libp2p/mdns";
 import { peerIdFromPrivateKey, peerIdFromString } from "@libp2p/peer-id";
 import { ping } from "@libp2p/ping";
 import { tcp } from "@libp2p/tcp";
+import { uPnPNAT } from "@libp2p/upnp-nat";
 import { isPrivate, lpStream } from "@libp2p/utils";
 import { webSockets } from "@libp2p/websockets";
 import { multiaddr } from "@multiformats/multiaddr";
+import { PrivateKey } from "@bsv/sdk";
 import * as dagCbor from "@ipld/dag-cbor";
 import { createLibp2p } from "libp2p";
 import { CID } from "multiformats/cid";
@@ -80,8 +106,22 @@ import { sha256 } from "multiformats/hashes/sha2";
 import { MESSAGE_KEY_ID, MESSAGE_PROTOCOL as SIGN_PROTOCOL } from "./providers.js";
 import { verifyAnyone } from "../runtime/identity.js";
 import { Liveness } from "./liveness.js";
-/** The default listeners: loopback TCP and WebSocket, ports chosen by the OS (plain WS on loopback: dev only). */
-export const DEFAULT_LISTEN = ["/ip4/127.0.0.1/tcp/0", "/ip4/127.0.0.1/tcp/0/ws"];
+/** SKEIN_NETWORK's names as the networks' own (the Teranode block topic's, the skein DHT's). */
+export const NETWORK_NAMES = { main: "mainnet", test: "testnet", regtest: "regtest" };
+/** The skein DHT's protocol for a network: the overlay's provider records, never merged with another network's. */
+export const skeinDhtProtocol = (network = "main") => `/skein/kad/${NETWORK_NAMES[network] ?? network}/1.0.0`;
+/**
+ * The default TCP port (2026-11-01): one fixed port on every install, so a user who opens one port knows
+ * which. 7534 is "SKEI" on a phone keypad; unassigned in the IANA registry (not IPFS's 4001, not
+ * Teranode's 9905/9915).
+ */
+export const DEFAULT_PORT = 7534;
+/** The default listeners: TCP on every interface, IPv4 and IPv6, on DEFAULT_PORT; WebSocket on loopback, its port the OS's (plain WS off loopback: dev only). */
+export const DEFAULT_LISTEN = [`/ip4/0.0.0.0/tcp/${DEFAULT_PORT}`, `/ip6/::/tcp/${DEFAULT_PORT}`, "/ip4/127.0.0.1/tcp/0/ws"];
+/** Loopback only, ports chosen by the OS: the router's listeners when it is given no host settings (tests, an embedded router). */
+export const LOOPBACK_LISTEN = ["/ip4/127.0.0.1/tcp/0", "/ip4/127.0.0.1/tcp/0/ws"];
+/** `listen` with DEFAULT_PORT made an OS-chosen port (the fallback when the default port is taken). */
+export const anyPort = (listen) => listen.map((a) => a.replace(new RegExp(`/tcp/${DEFAULT_PORT}(?=/|$)`), "/tcp/0"));
 /** The stream protocol a signed message travels on to an instance (#70). */
 export const MESSAGE_PROTOCOL = "/skein/message/1.0.0";
 /**
@@ -116,29 +156,69 @@ export async function topicCid(topic) {
 }
 // ---------------------------------------------------------------- config
 const list = (s) => (s ?? "").split(/[,\s]+/).map((x) => x.trim()).filter(Boolean);
-/** The host-wide settings: the environment's SKEIN_LIBP2P_*, else $SKEIN_HOME/host.env's. */
+/**
+ * The network's overlay bootstrap peers (SKEIN_NETWORK's names): the hosted Open Exchange node per network,
+ * dialled beside SKEIN_LIBP2P_BOOTSTRAP's (unioned, as TERANODE_BOOTSTRAP is with SKEIN_TERANODE_BOOTSTRAP).
+ * A node whose own peer id is one of them skips it (discover()). Mainnet and regtest have none yet.
+ */
+export const OVERLAY_BOOTSTRAP = {
+    test: ["/dns4/p2p.testnet.openex.dev/tcp/7534/p2p/16Uiu2HAmVN7Cc7TrFGVrbdoV1mMGBF8LQBvPZ5trzgPArfagBRSB"],
+};
+/** SKEIN_LIBP2P_BOOTSTRAP over the network's defaults: unset, the network's; a list, unioned with them; `off`, none at all. */
+export function overlayBootstrap(network, named) {
+    if ((named ?? "").trim().toLowerCase() === "off")
+        return [];
+    return [...new Set([...(OVERLAY_BOOTSTRAP[network] ?? []), ...list(named)])];
+}
+/**
+ * The bootstrap addresses a node dials now: not its own peer id (the hosted node is its network's default
+ * bootstrap), not a peer already connected; an address that does not parse is reported and skipped.
+ */
+export function bootstrapDials(bootstrap, self, connected, bad = () => { }) {
+    const out = [];
+    for (const a of bootstrap) {
+        let ma;
+        try {
+            ma = multiaddr(a);
+        }
+        catch {
+            bad(a);
+            continue;
+        }
+        const id = ma.getComponents().find((c) => c.name === "p2p")?.value;
+        if (id === self || (id && connected.has(id)))
+            continue;
+        out.push(a);
+    }
+    return out;
+}
+/** The host-wide settings: the environment's SKEIN_LIBP2P_* (and SKEIN_NETWORK), else $SKEIN_HOME/host.env's. */
 export function hostP2PConfig(vars, home) {
     const file = {};
     const envFile = home ? join(home, "host.env") : undefined;
     if (envFile && existsSync(envFile)) {
         for (const line of readFileSync(envFile, "utf8").split("\n")) {
-            const m = /^\s*(?:export\s+)?(SKEIN_LIBP2P_[A-Z_]+)=(.*)$/.exec(line);
+            const m = /^\s*(?:export\s+)?(SKEIN_LIBP2P_[A-Z_]+|SKEIN_NETWORK)=(.*)$/.exec(line);
             if (m)
                 file[m[1]] = m[2].trim().replace(/^(["'])(.*)\1$/, "$2");
         }
     }
     const get = (k) => vars[k] ?? file[k];
-    const dht = (get("SKEIN_LIBP2P_DHT") || "off").toLowerCase();
-    if (dht !== "off" && dht !== "client" && dht !== "server")
-        throw new Error(`SKEIN_LIBP2P_DHT: off | client | server, not ${dht}`);
+    const dht = (get("SKEIN_LIBP2P_DHT") || "auto").toLowerCase(); // 2026-11-01: auto by default; 2026-11-02: the skein DHT's mode only (Teranode's is always a client; off = neither)
+    if (dht !== "off" && dht !== "auto" && dht !== "client" && dht !== "server")
+        throw new Error(`SKEIN_LIBP2P_DHT: off | auto | client | server, not ${dht}`);
+    const upnp = (get("SKEIN_LIBP2P_UPNP") || "on").toLowerCase();
+    if (!/^(on|off|1|0|true|false|yes|no)$/.test(upnp))
+        throw new Error(`SKEIN_LIBP2P_UPNP: on | off, not ${upnp}`);
     const cert = get("SKEIN_LIBP2P_TLS_CERT"), key = get("SKEIN_LIBP2P_TLS_KEY");
     const listen = list(get("SKEIN_LIBP2P_LISTEN"));
     return {
         listen: listen.length ? listen : DEFAULT_LISTEN,
-        bootstrap: list(get("SKEIN_LIBP2P_BOOTSTRAP")),
+        bootstrap: overlayBootstrap(get("SKEIN_NETWORK") || "main", get("SKEIN_LIBP2P_BOOTSTRAP")),
         dht,
         relays: list(get("SKEIN_LIBP2P_RELAYS")),
         mdns: /^(on|1|true|yes)$/i.test(get("SKEIN_LIBP2P_MDNS") ?? ""),
+        upnp: /^(on|1|true|yes)$/.test(upnp),
         ...(cert && key ? { tls: { cert: readFileSync(cert, "utf8"), key: readFileSync(key, "utf8") } } : {}),
     };
 }
@@ -358,8 +438,8 @@ const u64 = (n) => { const b = new Uint8Array(8); new DataView(b.buffer).setBigU
 export const TOPIC_REQUIRED = "topic required";
 export class P2PHost {
     o;
-    /** The liveness tool's state (#138): the apps' liveness and the beats kept, in memory. */
-    live = new Liveness();
+    /** The liveness tool's state (#138): the apps' liveness and the beats kept (persisted in `o.beats` when given). */
+    live;
     /** The nodes, by peer ID (#160: one per key). */
     nodes = new Map();
     /** Each handle's node. */
@@ -369,15 +449,85 @@ export class P2PHost {
     /** Each key's declares, in order (one at a time). */
     starting = new Map();
     stopped = false;
+    /** The host node's key (hostKey, else a fresh one) and its peer ID. */
+    hostKey;
+    hostId;
     constructor(o) {
         this.o = o;
+        this.live = new Liveness(Date.now, o.beats);
+        this.hostKey = o.hostKey ?? PrivateKey.fromRandom();
+        this.hostId = peerIdOf(this.hostKey).toString();
         if (o.beat)
             this.live.kept = (h, topic, b) => { if (b.from !== this.peerId(h))
                 o.beat(h, topic, b); };
     }
     say(source, line) { this.o.log?.(source, line); }
-    /** A node's name in a log line: its one handle (as before #160), else its first. */
-    nameOf(n) { return n.handles.keys().next().value ?? n.id; }
+    /** A node's name in a log line: its one handle (as before #160), else its first; the host node with none: the router. */
+    nameOf(n) { return n.handles.keys().next().value ?? (n.host ? "router" : n.id); }
+    // ---------------------------------------------------------------- the host node (#156)
+    /**
+     * The host node: the node of the host key, started (once) with no handles when no instance has
+     * started it yet; an instance on that key that starts later joins it (#160), one that started
+     * earlier made it.
+     */
+    async hostNode() {
+        if (this.stopped)
+            throw new Error("libp2p: stopped");
+        const key = this.hostId;
+        const prev = this.starting.get(key) ?? Promise.resolve();
+        const next = prev.catch(() => { }).then(async () => {
+            if (this.stopped)
+                throw new Error("libp2p: stopped");
+            const n = this.nodes.get(key);
+            if (n) {
+                n.host = true;
+                return n;
+            }
+            const made = await this.start(key, this.hostKey, undefined, undefined);
+            if (!made)
+                throw new Error("libp2p: stopped");
+            return made;
+        });
+        this.starting.set(key, next);
+        void next.catch(() => { }).finally(() => { if (this.starting.get(key) === next)
+            this.starting.delete(key); });
+        return (await next).node;
+    }
+    /** The host node's record, once it runs. */
+    hostOf() { const n = this.nodes.get(this.hostId); return n?.host ? n : undefined; }
+    /**
+     * A host topic on the host node (#156: the Teranode block topic): subscribed, each message judged
+     * by `take` alone (its verdict GossipSub's), never the front door, never advertised on the skein
+     * DHT. Undefined `take`: the topic left.
+     */
+    async hostTopic(topic, take) {
+        await this.hostNode();
+        const n = this.hostOf();
+        if (take)
+            n.hostTopics.set(topic, take);
+        else
+            n.hostTopics.delete(topic);
+        this.resubscribe(n);
+    }
+    /** The peers the host node knows subscribe `topic` (GossipSub's view). */
+    hostSubscribers(topic) {
+        const n = this.hostOf();
+        return n ? this.pubsub(n).getSubscribers(topic).map((p) => p.toString()) : [];
+    }
+    /** The host node's skein DHT's mode now (client | server; undefined: off or no host node yet). */
+    hostDhtMode() {
+        return this.hostDht()?.getMode();
+    }
+    /** The host node's confirmed public addresses (AutoNAT's, or UPnP's once AutoNAT confirmed them): libp2p announces only confirmed ones; relay addresses aside. */
+    hostPublicAddrs() {
+        const n = this.hostOf();
+        return n ? n.node.getMultiaddrs().filter((m) => !isPrivateAddr(m) && !m.toString().includes("/p2p-circuit")).map(String) : [];
+    }
+    /** The host node's DHT service, the skein DHT (undefined: SKEIN_LIBP2P_DHT=off, or no host node yet). */
+    hostDht() {
+        const n = this.hostOf();
+        return n ? dhtOf(n.node) : undefined;
+    }
     /** The node of an instance, if it has one. */
     node(handle) { return this.byHandle.get(handle)?.node; }
     /** An instance's peer ID (derived: whether or not its node runs). */
@@ -412,7 +562,7 @@ export class P2PHost {
             const n = this.byHandle.get(handle) ?? this.nodes.get(key);
             if (n)
                 return this.reconfigure(n, handle, config);
-            await this.start(key, handle, config);
+            await this.start(key, this.o.keyOf(handle), handle, config);
         });
         this.starting.set(key, next);
         // Only clears the slot: the error reaches this call's caller through `await next` below.
@@ -461,9 +611,9 @@ export class P2PHost {
     }
     /** The topics `handle` takes: its config's and its apps' liveness topics (#138). */
     takes(handle, h) { return [...h.config.topics, ...this.live.topics(handle)]; }
-    /** Subscribe what the handles' configs and liveness tools (#138) take, unsubscribe the rest: the topics added and removed. */
+    /** Subscribe what the handles' configs and liveness tools (#138) take, and the host's own topics (#156), unsubscribe the rest: the topics added and removed. */
     resubscribe(n) {
-        const want = new Set([...n.handles].flatMap(([handle, h]) => this.takes(handle, h)));
+        const want = new Set([...[...n.handles].flatMap(([handle, h]) => this.takes(handle, h)), ...n.hostTopics.keys()]);
         const ps = this.pubsub(n);
         const removed = [...n.subscribed].filter((t) => !want.has(t));
         const added = [...want].filter((t) => !n.subscribed.has(t));
@@ -545,20 +695,26 @@ export class P2PHost {
     async handleProtocol(n, protocol) {
         await n.node.handle(protocol, (stream, connection) => { void this.serve(n, protocol, stream, connection.remotePeer); }, { runOnLimitedConnection: true });
     }
-    async start(key, handle, config) {
+    /** A node for `key` (its private key `pk`): with `handle` and its config, or the host node with none (#156). */
+    async start(key, pk, handle, config) {
         const h = this.o.host;
-        const n = { id: key, node: undefined, handles: new Map([[handle, { config, streams: new Map(), beats: new Map() }]]), seqnos: new Map(), subscribed: new Set(), handled: new Set() };
-        const listen = [...(config.listen ?? h.listen), ...h.relays.map((r) => `${r.replace(/\/+$/, "")}/p2p-circuit`)];
+        const n = {
+            id: key, node: undefined, handles: new Map(handle && config ? [[handle, { config, streams: new Map(), beats: new Map() }]] : []),
+            seqnos: new Map(), subscribed: new Set(), handled: new Set(), hostTopics: new Map(), ...(key === this.hostId ? { host: true } : {}),
+        };
+        const listen = [...(config?.listen ?? h.listen), ...h.relays.map((r) => `${r.replace(/\/+$/, "")}/p2p-circuit`)];
         // An address that does not parse counts as private here; start() reports it when it is dialled or listened on.
-        const privateDev = [...h.bootstrap, ...listen].every((a) => { try {
+        const allPrivate = (xs) => xs.every((a) => { try {
             return isPrivateAddr(multiaddr(a));
         }
         catch {
             return true;
         } });
+        const privateDev = allPrivate([...h.bootstrap, ...listen]);
         const services = {
             identify: identify(),
-            ping: ping(),
+            // #156: the DHT pings a new peer (before it enters its table) beside the other pings; 4 outbound streams as before.
+            ping: ping({ maxOutboundStreams: 4 }),
             pubsub: gossipsub({
                 globalSignaturePolicy: "StrictSign",
                 allowPublishToZeroTopicPeers: true,
@@ -579,36 +735,73 @@ export class P2PHost {
                 },
             }),
         };
-        if (h.dht !== "off")
-            services.dht = kadDHT({ clientMode: h.dht === "client", peerInfoMapper: privateDev ? passthroughMapper : removePrivateAddressesMapper });
-        const node = await createLibp2p({
-            privateKey: libp2pKey(this.o.keyOf(handle)),
-            addresses: { listen },
+        // #156: one DHT, ours (the overlay topics'); 2026-11-02: no Teranode DHT (the public IPFS DHT: even a client fills the connection cap).
+        if (h.dht !== "off") {
+            services.skeinDht = kadDHT({
+                protocol: skeinDhtProtocol(h.network), ...dhtClientMode(h.dht), peerInfoMapper: privateDev ? passthroughMapper : removePrivateAddressesMapper,
+                logPrefix: "libp2p:dht-skein", datastorePrefix: "/dht-skein", metricsPrefix: "libp2p_dht_skein",
+            });
+        }
+        // 2026-11-01: AutoNAT confirms the node's public addresses (DHT auto flips to server on one; UPnP's mapped address needs it).
+        if (h.upnp || h.dht === "auto" || h.dht === "server")
+            services.autoNAT = autoNAT();
+        if (h.upnp)
+            services.upnpNAT = uPnPNAT();
+        const name = handle ?? "router";
+        const create = (addrs) => createLibp2p({
+            privateKey: libp2pKey(pk),
+            addresses: { listen: addrs },
             transports: [tcp(), webSockets(h.tls ? { https: { cert: h.tls.cert, key: h.tls.key } } : {}), ...(h.relays.length ? [circuitRelayTransport()] : [])],
             connectionEncrypters: [noise()],
             streamMuxers: [yamux()],
             peerDiscovery: h.mdns ? [mdns()] : [],
             services: services,
+            ...(h.upnp ? { logger: upnpTold((line) => this.say(name, line)) } : {}),
+            start: false,
         });
+        let node = await create(listen);
+        try {
+            await node.start();
+        }
+        catch (e) {
+            try {
+                await node.stop();
+            }
+            catch { /* the failed start's listeners closed as far as they go */ }
+            // 2026-11-01: the default port taken (another host, another node of this one): an OS-chosen port on the same interfaces.
+            // An address SKEIN_LIBP2P_LISTEN (or the instance) names is honoured as named: its failure stops the node, as before.
+            const defaulted = !config?.listen && h.listen.join(" ") === DEFAULT_LISTEN.join(" ");
+            if (!defaulted || !/EADDRINUSE/.test(e.message))
+                throw e;
+            const fallback = anyPort(listen);
+            this.say(name, `libp2p: port ${DEFAULT_PORT} is taken: listening on an OS-chosen port instead`);
+            node = await create(fallback);
+            await node.start();
+        }
         n.node = node;
         if (this.stopped) {
             await node.stop();
             return undefined;
         }
         this.nodes.set(key, n);
-        this.byHandle.set(handle, n);
+        if (handle)
+            this.byHandle.set(handle, n);
         if (h.mdns)
             node.addEventListener("peer:discovery", (e) => { void node.dial(e.detail.id).catch((err) => this.say(this.nameOf(n), `libp2p: mDNS peer ${e.detail.id}: ${err.message}`)); });
         this.resubscribe(n);
         const host = this.o.hostProtocols ?? {};
-        for (const protocol of config.protocols.filter((p) => inboundRow(p, host))) {
+        for (const protocol of (config?.protocols ?? []).filter((p) => inboundRow(p, host))) {
             n.handled.add(protocol);
             await this.handleProtocol(n, protocol);
         }
         await this.handleProtocol(n, MESSAGE_PROTOCOL);
         for (const [protocol, f] of Object.entries(host))
             await this.handleHostProtocol(n, protocol, f);
-        this.say(handle, `libp2p: peer ${node.peerId} listening on ${node.getMultiaddrs().map(String).join(" ") || "(nothing)"}; topics ${config.topics.join(", ") || "none"}; protocols ${config.protocols.join(", ") || "none"}`);
+        const dhts = (h.dht === "off" ? "DHT off" : `DHT ${h.dht} (${skeinDhtProtocol(h.network)})`) + `; UPnP ${h.upnp ? "on" : "off"}; bootstrap ${h.bootstrap.join(", ") || "none"}`;
+        if (handle && config)
+            this.say(handle, `libp2p: peer ${node.peerId} listening on ${node.getMultiaddrs().map(String).join(" ") || "(nothing)"}; topics ${config.topics.join(", ") || "none"}; protocols ${config.protocols.join(", ") || "none"}; ${dhts}`);
+        else
+            this.say("router", `libp2p: the host node, peer ${node.peerId} listening on ${node.getMultiaddrs().map(String).join(" ") || "(nothing)"}; ${dhts}`);
         const discover = () => void this.discover(n).catch((e) => this.say(this.nameOf(n), `libp2p: discovery: ${e.message}`));
         setTimeout(discover, 200);
         n.timer = setInterval(discover, this.o.discoveryMs ?? 30_000);
@@ -620,28 +813,19 @@ export class P2PHost {
         const node = n.node;
         const name = this.nameOf(n);
         const connected = new Set(node.getConnections().map((c) => c.remotePeer.toString()));
-        for (const a of this.o.host.bootstrap) {
-            let ma;
-            try {
-                ma = multiaddr(a);
-            }
-            catch {
-                this.say(name, `libp2p: bad bootstrap address ${a}`);
-                continue;
-            }
-            const id = ma.getComponents().find((c) => c.name === "p2p")?.value;
-            if (id === node.peerId.toString() || (id && connected.has(id)))
-                continue;
-            await node.dial(ma).catch((e) => this.say(name, `libp2p: bootstrap ${a}: ${e.message}`));
+        for (const a of bootstrapDials(this.o.host.bootstrap, node.peerId.toString(), connected, (b) => this.say(name, `libp2p: bad bootstrap address ${b}`))) {
+            await node.dial(multiaddr(a)).catch((e) => this.say(name, `libp2p: bootstrap ${a}: ${e.message}`));
         }
-        if (this.o.host.dht === "off" || !node.services.dht)
+        // #156: the skein DHT (the node's one DHT); the host's own topics are the tracker's.
+        const dht = dhtOf(node);
+        if (!dht)
             return;
-        for (const topic of [...n.subscribed]) {
+        for (const topic of [...n.subscribed].filter((t) => !n.hostTopics.has(t))) {
             const cid = await topicCid(topic);
-            await node.contentRouting.provide(cid, { signal: AbortSignal.timeout(20_000) }).catch((e) => { if (!timedOut(e))
+            await drain(dht.provide(cid, { signal: AbortSignal.timeout(20_000) })).catch((e) => { if (!timedOut(e))
                 this.say(name, `libp2p: provide ${topic}: ${e.message}`); });
             try {
-                for await (const p of node.contentRouting.findProviders(cid, { signal: AbortSignal.timeout(20_000) })) {
+                for await (const p of providersOf(dht, cid, { signal: AbortSignal.timeout(20_000) })) {
                     if (p.id.equals(node.peerId) || node.getConnections(p.id).length)
                         continue;
                     await node.dial(p.multiaddrs.length ? p.multiaddrs : p.id).catch((e) => this.say(name, `libp2p: ${topic} provider ${p.id}: ${e.message}`));
@@ -666,6 +850,19 @@ export class P2PHost {
     async validate(n, topic, _source, msg) {
         if (msg.type !== "signed")
             return TopicValidatorResult.Reject;
+        // #156: a host topic is judged by its handler alone (the tracker's), never the front door.
+        const own = n.hostTopics.get(topic);
+        if (own) {
+            let v;
+            try {
+                v = own(msg.data, msg.from);
+            }
+            catch (e) {
+                this.say(this.nameOf(n), `libp2p: ${topic}: ${e.message}`);
+                v = "ignore";
+            } // the host failing is not the message's fault
+            return v === "accept" ? TopicValidatorResult.Accept : v === "reject" ? TopicValidatorResult.Reject : TopicValidatorResult.Ignore;
+        }
         const takers = [...n.handles].filter(([handle, h]) => h.config.topics.includes(topic) || this.live.takes(handle, topic));
         if (!takers.length)
             return TopicValidatorResult.Ignore;
@@ -948,7 +1145,7 @@ export class P2PHost {
             clearInterval(b.timer);
         hs?.beats.clear();
         this.live.drop(handle);
-        if (n.handles.size) {
+        if (n.handles.size || n.host) {
             this.resubscribe(n);
             await this.rehandle(n).catch((e) => this.say(handle, `libp2p: leaving its key's node: ${e.message}`));
             this.say(handle, `libp2p: left the node of its key ${n.id} (${n.handles.size} instances on it)`);
@@ -972,7 +1169,7 @@ export class P2PHost {
                 for (const b of hs.beats.values())
                     clearInterval(b.timer);
                 this.byHandle.delete(handle);
-                this.live.drop(handle);
+                this.live.forget(handle); // the host stopping: its stored beats stay for the next start
             }
             n.handles.clear();
             this.nodes.delete(n.id);
@@ -987,7 +1184,7 @@ export class P2PHost {
     }
 }
 /** A multiaddr on a loopback or private network (dev: the DHT keeps such addresses). */
-function isPrivateAddr(ma) {
+export function isPrivateAddr(ma) {
     const c = ma.getComponents().find((x) => x.name.startsWith("dns"));
     if (c?.value)
         return c.value === "localhost" || c.value.endsWith(".localhost");
@@ -1000,3 +1197,51 @@ function isPrivateAddr(ma) {
 }
 /** An AbortSignal.timeout's abort: the DHT's 20-second rounds end this way, and the next round tries again. */
 const timedOut = (e) => e instanceof Error && (e.name === "TimeoutError" || e.name === "AbortError");
+/**
+ * kad-DHT's clientMode for a mode of the skein DHT (2026-11-01; @libp2p/kad-dht 16.4.5 kad-dht.js): `auto` leaves it
+ * unset — the DHT's own switch (a client, a server while the node has a confirmed public address);
+ * `client` true — only ever a client; `server` false — a server from its start (its start sets the mode),
+ * never switched back. An explicit false is NOT auto in this version: the switch listens only when unset.
+ */
+export function dhtClientMode(mode) {
+    return mode === "auto" ? {} : { clientMode: mode === "client" };
+}
+/**
+ * The libp2p logger, with the UPnP service's outcome told once per distinct line (2026-11-01): the gateway
+ * search's result, the public IP found, each mapping made or refused, an error. The service reports its
+ * outcome nowhere else (its log only); every other component's log is the default, untouched.
+ */
+export function upnpTold(tell) {
+    const base = defaultLogger();
+    const said = new Set();
+    const fmt = (f, args) => { let i = 0; return String(f).replace(/%[sdioOjaepcbt]/g, () => { const a = args[i++]; return a instanceof Error ? a.message : String(a); }); };
+    const once = (line) => { if (!said.has(line)) {
+        said.add(line);
+        tell(line);
+    } };
+    const outcome = /^(gateway search finished|discovered public IP|created mapping)/;
+    const wrap = (log) => Object.assign((f, ...args) => { log(f, ...args); if (outcome.test(String(f)))
+        once(`libp2p: UPnP ${fmt(f, args)}`); }, {
+        error: (f, ...args) => { log.error(f, ...args); once(`libp2p: UPnP ${fmt(f, args)}`); },
+        trace: log.trace.bind(log),
+        enabled: log.enabled,
+        newScope: (s) => wrap(log.newScope(s)),
+    });
+    return { forComponent: (c) => c.startsWith("libp2p:upnp-nat") ? wrap(base.forComponent(c)) : base.forComponent(c) };
+}
+/** A node's DHT service, the skein DHT (#156), or undefined (SKEIN_LIBP2P_DHT=off). */
+export function dhtOf(node) {
+    return node.services.skeinDht;
+}
+/** The providers a DHT finds for `cid` (its PROVIDER events' peers), on that DHT alone. */
+export async function* providersOf(dht, cid, options = {}) {
+    for await (const e of dht.findProviders(cid, options))
+        if (e.name === "PROVIDER")
+            yield* e.providers;
+}
+/** Run a DHT operation's events to the end. */
+export async function drain(events) { for await (const _ of events) { /* the events: not needed */ } }
+/** A DHT's routing table size (undefined: no such DHT). */
+export function tableSize(dht) {
+    return dht?.routingTable?.size;
+}