@openclaw/nostr 2026.7.1-beta.2 → 2026.7.1-beta.4

package/dist/api.js

@@ -1,11 +1,12 @@
-import { o as resolveNostrAccount } from "./setup-surface-BqBa2C0K.js";
+import { o as resolveNostrAccount } from "./setup-surface-CKamwGa3.js";
 import { getPluginRuntimeGatewayRequestScope } from "./runtime-api.js";
 import { n as NostrProfileSchema } from "./config-schema-DIiXiBKr.js";
-import { a as setNostrRuntime, i as getNostrRuntime, n as nostrPlugin, o as contentToProfile, r as publishNostrProfile, t as getNostrProfileState } from "./channel-CV0aX1uq.js";
+import { a as setNostrRuntime, i as getNostrRuntime, n as nostrPlugin, o as contentToProfile, r as publishNostrProfile, t as getNostrProfileState } from "./channel-B2Y66pl3.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, readStringValue } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { z } from "zod";
 import { SimplePool, verifyEvent } from "nostr-tools";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 import { readJsonBodyWithLimit, requestBodyErrorToText } from "openclaw/plugin-sdk/webhook-request-guards";
 import { createFixedWindowRateLimiter } from "openclaw/plugin-sdk/webhook-ingress";
 import { isBlockedHostnameOrIp } from "openclaw/plugin-sdk/ssrf-runtime";
@@ -199,21 +200,9 @@ const profileRateLimiter = createFixedWindowRateLimiter({
 function checkRateLimit(accountId) {
 	return !profileRateLimiter.isRateLimited(accountId);
 }
-const publishLocks = /* @__PURE__ */ new Map();
+const publishLocks = new KeyedAsyncQueue();
 async function withPublishLock(accountId, fn) {
-	const prev = publishLocks.get(accountId) ?? Promise.resolve();
-	let resolve;
-	const next = new Promise((r) => {
-		resolve = r;
-	});
-	publishLocks.set(accountId, next);
-	await prev.catch(() => {});
-	try {
-		return await fn();
-	} finally {
-		resolve();
-		if (publishLocks.get(accountId) === next) publishLocks.delete(accountId);
-	}
+	return await publishLocks.enqueue(accountId, fn);
 }
 const nip05FormatSchema = z.string().regex(/^[a-z0-9._-]+@[a-z0-9.-]+\.[a-z]{2,}$/i, "Invalid NIP-05 format (user@domain.com)").optional();
 const lud16FormatSchema = z.string().regex(/^[a-z0-9._-]+@[a-z0-9.-]+\.[a-z]{2,}$/i, "Invalid Lightning address format").optional();

package/dist/{channel-CV0aX1uq.js → channel-B2Y66pl3.js}

@@ -1,4 +1,4 @@
-import { a as resolveDefaultNostrAccountId, c as validatePrivateKey, i as listNostrAccountIds, n as nostrSetupWizard, o as resolveNostrAccount, s as normalizePubkey, t as nostrSetupAdapter } from "./setup-surface-BqBa2C0K.js";
+import { a as resolveDefaultNostrAccountId, c as validatePrivateKey, i as listNostrAccountIds, n as nostrSetupWizard, o as resolveNostrAccount, s as normalizePubkey, t as nostrSetupAdapter } from "./setup-surface-CKamwGa3.js";
 import { a as collectStatusIssuesFromLastError, i as buildChannelConfigSchema, n as NostrProfileSchema, o as createDefaultChannelRuntimeState, r as DEFAULT_ACCOUNT_ID, s as formatPairingApproveHint, t as NostrConfigSchema } from "./config-schema-DIiXiBKr.js";
 import { i as DEFAULT_RELAYS } from "./setup-adapter-DEU3o8MF.js";
 import { t as normalizeNostrStateAccountId } from "./state-account-id-CvBZ9s6P.js";
@@ -969,7 +969,8 @@ async function startNostrBus(options) {
 		await sendEncryptedDm(pool, sk, toPubkey, text, relays, metrics, circuitBreakers, healthTracker, onError);
 	};
 	const publishProfile$1 = async (profile) => {
-		const result = await publishProfile(pool, sk, relays, profile, (await readNostrProfileState({ accountId }))?.lastPublishedAt ?? void 0);
+		const lastPublishedAt = (await readNostrProfileState({ accountId }))?.lastPublishedAt ?? void 0;
+		const result = await publishProfile(pool, sk, relays, profile, lastPublishedAt);
 		const publishResults = {};
 		for (const relay of result.successes) publishResults[relay] = "ok";
 		for (const { relay, error } of result.failures) publishResults[relay] = error === "timeout" ? "timeout" : "failed";
@@ -1276,13 +1277,19 @@ function getActiveNostrBuses() {
 //#endregion
 //#region extensions/nostr/src/session-route.ts
 function resolveNostrOutboundSessionRoute(params) {
-	const target = stripChannelTargetPrefix(params.target, "nostr");
-	if (!target) return null;
+	const rawTarget = stripChannelTargetPrefix(params.target, "nostr");
+	let target;
+	try {
+		target = normalizePubkey(rawTarget);
+	} catch {
+		return null;
+	}
 	return buildChannelOutboundSessionRoute({
 		cfg: params.cfg,
 		agentId: params.agentId,
 		channel: "nostr",
 		accountId: params.accountId,
+		recipientSessionExact: true,
 		peer: {
 			kind: "direct",
 			id: target

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { n as nostrPlugin } from "./channel-CV0aX1uq.js";
+import { n as nostrPlugin } from "./channel-B2Y66pl3.js";
 export { nostrPlugin };

package/dist/doctor-contract-api.js

@@ -1,6 +1,7 @@
 import { t as normalizeNostrStateAccountId } from "./state-account-id-CvBZ9s6P.js";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { archiveLegacyStateSource } from "openclaw/plugin-sdk/runtime-doctor";
 //#region extensions/nostr/doctor-contract-api.ts
 const BUS_STATE_NAMESPACE = "bus-state";
 const PROFILE_STATE_NAMESPACE = "profile-state";
@@ -35,13 +36,6 @@ function parseProfileState(value) {
 		lastPublishResults: rawResults === null || Object.keys(lastPublishResults).length === 0 ? null : lastPublishResults
 	};
 }
-async function fileExists(filePath) {
-	try {
-		return (await fs.stat(filePath)).isFile();
-	} catch {
-		return false;
-	}
-}
 async function readJsonFile(filePath) {
 	return JSON.parse(await fs.readFile(filePath, "utf8"));
 }
@@ -70,19 +64,6 @@ async function listLegacyFiles(params) {
 	}
 	return files;
 }
-async function archiveLegacySource(params) {
-	const archivedPath = `${params.filePath}.migrated`;
-	if (await fileExists(archivedPath)) {
-		params.warnings.push(`Left migrated ${params.label} source in place because ${archivedPath} already exists`);
-		return;
-	}
-	try {
-		await fs.rename(params.filePath, archivedPath);
-		params.changes.push(`Archived ${params.label} legacy source -> ${archivedPath}`);
-	} catch (err) {
-		params.warnings.push(`Failed archiving ${params.label} legacy source: ${String(err)}`);
-	}
-}
 async function ensureStoreCapacity(params) {
 	const existingKeys = new Set((await params.store.entries()).map((entry) => entry.key));
 	const missingKeys = new Set(params.files.map((file) => file.accountId).filter((key) => !existingKeys.has(key)));
@@ -134,7 +115,7 @@ const stateMigrations = [{
 				existingKeys.add(file.accountId);
 				imported++;
 			}
-			await archiveLegacySource({
+			await archiveLegacyStateSource({
 				filePath: file.filePath,
 				label: "Nostr bus state",
 				changes,
@@ -189,7 +170,7 @@ const stateMigrations = [{
 				existingKeys.add(file.accountId);
 				imported++;
 			}
-			await archiveLegacySource({
+			await archiveLegacyStateSource({
 				filePath: file.filePath,
 				label: "Nostr profile state",
 				changes,

package/dist/setup-api.js

@@ -1,2 +1,2 @@
-import { n as nostrSetupWizard, t as nostrSetupAdapter } from "./setup-surface-BqBa2C0K.js";
+import { n as nostrSetupWizard, t as nostrSetupAdapter } from "./setup-surface-CKamwGa3.js";
 export { nostrSetupAdapter, nostrSetupWizard };

package/dist/setup-plugin-api.js

@@ -51,7 +51,7 @@ const nostrSetupAdapter = createNostrSetupAdapter({
 });
 const nostrSetupWizard = createDelegatedSetupWizardProxy({
 	channel,
-	loadWizard: async () => (await import("./setup-surface-BqBa2C0K.js").then((n) => n.r)).nostrSetupWizard,
+	loadWizard: async () => (await import("./setup-surface-CKamwGa3.js").then((n) => n.r)).nostrSetupWizard,
 	status: { ...createStandardChannelSetupStatus({
 		channelLabel: "Nostr",
 		configuredLabel: t("wizard.channels.statusConfigured"),

package/dist/{setup-surface-BqBa2C0K.js → setup-surface-CKamwGa3.js}

@@ -30,7 +30,7 @@ function validatePrivateKey(key) {
 		return decoded.data;
 	}
 	if (!/^[0-9a-fA-F]{64}$/.test(trimmed)) throw new Error("Private key must be 64 hex characters or nsec bech32 format");
-	const bytes = new Uint8Array(32);
+	const bytes = /* @__PURE__ */ new Uint8Array(32);
 	for (let i = 0; i < 32; i++) bytes[i] = Number.parseInt(trimmed.slice(i * 2, i * 2 + 2), 16);
 	return bytes;
 }

package/node_modules/nostr-tools/README.md

@@ -130,34 +130,56 @@ import WebSocket from 'ws'
 useWebSocketImplementation(WebSocket)
 ```
 
-#### enablePing
+### Authenticating with relays (NIP-42)
 
-You can enable regular pings of connected relays with the `enablePing` option. This will set up a heartbeat that closes the websocket if it doesn't receive a response in time. Some platforms, like Node.js, don't report websocket disconnections due to network issues, and enabling this can increase the reliability of the `onclose` event.
+Some relays will return a `CLOSED` message with an `"auth-required:"` prefix in order to signal that such request requires authentication.
 
-```js
-import { SimplePool } from '@nostr/tools/pool'
-
-const pool = new SimplePool({ enablePing: true })
-```
+Upon receiving that you're supposed to send an `AUTH` message and restart the subscription.
 
-#### enableReconnect
+**Using `SimplePool`:**
 
-You can also enable automatic reconnection with the `enableReconnect` option. This will make the pool try to reconnect to relays with an exponential backoff delay if the connection is lost unexpectedly.
+`subscribeMany`, `subscribeManyEose` and `subscribeEose` accept `onauth` option. It signs challenge and resubscribes automatically for you:
 
 ```js
 import { SimplePool } from '@nostr/tools/pool'
 
-const pool = new SimplePool({ enableReconnect: true })
+const pool = new SimplePool()
+
+pool.subscribeMany(
+  ['wss://myrelay.com'],
+  [{ '#t': ['restricted'] }],
+  {
+    onevent(event) { console.log('got event:', event) },
+    onauth: (eventTemplate) => window.nostr.signEvent(eventTemplate),
+  }
+)
 ```
 
-Using both `enablePing: true` and `enableReconnect: true` is recommended as it will improve the reliability and timeliness of the reconnection (at the expense of slighly higher bandwidth due to the ping messages).
+**Using `Relay` directly:**
+
+Unrecommended unless you really need fine-grained control over each `Relay` object:
 
 ```js
-// on Node.js
-const pool = new SimplePool({ enablePing: true, enableReconnect: true })
-```
+import { Relay } from '@nostr/tools/relay'
+
+const relay = await Relay.connect('wss://myrelay.com')
+let alreadyAuthenticatedOnce = false
+const subscribe = () => {
+  relay.subscribe([{ '#t': ['restricted'] }], {
+    onevent(event) { console.log(event) },
+    onclose(reason) {
+      if (reason.startsWith('auth-required:')) {
+        if (alreadyAuthenticatedOnce) return
+        await relay.auth((eventTemplate) = window.nostr.signEvent(eventTemplate))
+        alreadyAuthenticatedOnce = true
+        subscribe()
+      }
+    }
+  })
+}
 
-When reconnecting, all existing subscriptions will have their filters automatically updated with `since:` set to the timestamp of the last event received on them `+1`, then restarted.
+subscribe()
+```
 
 ### Parsing references (mentions) from a content based on NIP-27
 

package/node_modules/nostr-tools/lib/cjs/abstract-pool.js

@@ -227,7 +227,9 @@ var AbstractRelay = class {
         connectionTimeoutHandle = setTimeout(() => {
           reject("connection timed out");
           this.connectionPromise = void 0;
-          this.skipReconnection = true;
+          if (this.reconnectAttempts === 0) {
+            this.skipReconnection = true;
+          }
           this.onclose?.();
           this.handleHardClose("relay connection timed out");
         }, opts.timeout);
@@ -271,7 +273,9 @@ var AbstractRelay = class {
         clearTimeout(connectionTimeoutHandle);
         reject("connection failed");
         this.connectionPromise = void 0;
-        this.skipReconnection = true;
+        if (this.reconnectAttempts === 0) {
+          this.skipReconnection = true;
+        }
         this.onclose?.();
         this.handleHardClose("relay connection failed");
       };
@@ -372,19 +376,38 @@ var AbstractRelay = class {
       }, this.publishTimeout);
       this.openEventPublishes.set(event.id, { resolve, reject, timeout });
     });
-    this.send('["EVENT",' + JSON.stringify(event) + "]");
+    try {
+      await this.send('["EVENT",' + JSON.stringify(event) + "]");
+    } catch (err) {
+      const ep = this.openEventPublishes.get(event.id);
+      if (ep) {
+        ep.reject(err);
+        this.openEventPublishes.delete(event.id);
+      }
+    }
     this.ongoingOperations--;
     if (this.ongoingOperations === 0)
       this.idleSince = Date.now();
     return ret;
   }
   async count(filters, params) {
+    return (await this.countWithHLL(filters, params)).count;
+  }
+  async countWithHLL(filters, params) {
     this.serial++;
     const id = params?.id || "count:" + this.serial;
     const ret = new Promise((resolve, reject) => {
       this.openCountRequests.set(id, { resolve, reject });
     });
-    this.send('["COUNT","' + id + '",' + JSON.stringify(filters).substring(1));
+    try {
+      await this.send('["COUNT","' + id + '",' + JSON.stringify(filters).substring(1));
+    } catch (err) {
+      const cr = this.openCountRequests.get(id);
+      if (cr) {
+        cr.reject(err);
+        this.openCountRequests.delete(id);
+      }
+    }
     return ret;
   }
   subscribe(filters, params) {
@@ -462,7 +485,7 @@ var AbstractRelay = class {
           const payload = data[2];
           const cr = this.openCountRequests.get(id);
           if (cr) {
-            cr.resolve(payload.count);
+            cr.resolve(payload);
             this.openCountRequests.delete(id);
           }
           return;
@@ -492,8 +515,14 @@ var AbstractRelay = class {
         case "CLOSED": {
           const id = data[1];
           const so = this.openSubs.get(id);
-          if (!so)
+          if (!so) {
+            const cr = this.openCountRequests.get(id);
+            if (cr) {
+              cr.reject(new Error(data[2]));
+              this.openCountRequests.delete(id);
+            }
             return;
+          }
           so.closed = true;
           so.close(data[2]);
           return;
@@ -602,6 +631,63 @@ var alwaysTrue = (t) => {
   return true;
 };
 
+// nip45.ts
+var import_sha2 = require("@noble/hashes/sha2.js");
+var import_utils3 = require("@noble/hashes/utils.js");
+var M = 256;
+var HLL_HEX_LENGTH = M * 2;
+var utf8Encoder2 = new TextEncoder();
+function getCountManyFilter(target, directive) {
+  switch (directive) {
+    case "reactions":
+      return { "#e": [target], kinds: [7] };
+    case "reposts":
+      return { "#e": [target], kinds: [6] };
+    case "quotes":
+      return { "#q": [target], kinds: [1, 1111] };
+    case "replies":
+      return { "#e": [target], kinds: [1] };
+    case "comments":
+      return { "#E": [target], kinds: [1111] };
+    case "followers":
+      return { "#p": [target], kinds: [3] };
+  }
+}
+function newHll() {
+  return new Uint8Array(M);
+}
+function hllDecode(hex) {
+  if (hex.length !== HLL_HEX_LENGTH || !/^[0-9a-fA-F]+$/.test(hex))
+    return void 0;
+  const registers = new Uint8Array(M);
+  for (let i = 0; i < M; i++) {
+    registers[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return registers;
+}
+function hllEncode(registers) {
+  if (registers.length !== M)
+    throw new Error(`invalid number of registers ${registers.length}`);
+  let hex = "";
+  for (let i = 0; i < M; i++) {
+    hex += registers[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function mergeHll(target, source) {
+  if (target.length === 0)
+    target = newHll();
+  if (target.length !== M)
+    throw new Error(`invalid number of registers ${target.length}`);
+  if (source.length !== M)
+    throw new Error(`invalid number of registers ${source.length}`);
+  for (let i = 0; i < M; i++) {
+    if (source[i] > target[i])
+      target[i] = source[i];
+  }
+  return target;
+}
+
 // abstract-pool.ts
 var AbstractSimplePool = class {
   relays = /* @__PURE__ */ new Map();
@@ -829,6 +915,48 @@ var AbstractSimplePool = class {
     events.sort((a, b) => b.created_at - a.created_at);
     return events[0] || null;
   }
+  async countMany(relays, target, directive, params) {
+    const filter = getCountManyFilter(target, directive);
+    const urls = [];
+    for (let i = 0; i < relays.length; i++) {
+      const url = normalizeURL(relays[i]);
+      if (urls.indexOf(url) === -1)
+        urls.push(url);
+    }
+    const responses = await Promise.all(
+      urls.map(async (url) => {
+        if (this.allowConnectingToRelay?.(url, ["read", [filter]]) === false)
+          return null;
+        let relay;
+        try {
+          relay = await this.ensureRelay(url, {
+            connectionTimeout: this.maxWaitForConnection < (params?.maxWait || 0) ? Math.max(params.maxWait * 0.8, params.maxWait - 1e3) : this.maxWaitForConnection,
+            abort: params?.abort
+          });
+        } catch (err) {
+          this.onRelayConnectionFailure?.(url);
+          return null;
+        }
+        this.onRelayConnectionSuccess?.(url);
+        return relay.countWithHLL([filter], { id: params?.id }).catch(() => null);
+      })
+    );
+    let count = 0;
+    let hll;
+    for (const response of responses) {
+      if (!response)
+        continue;
+      if (response.count > count)
+        count = response.count;
+      if (!response.hll || response.hll.length !== 512)
+        continue;
+      const registers = hllDecode(response.hll);
+      if (!registers)
+        continue;
+      hll = mergeHll(hll || new Uint8Array(0), registers);
+    }
+    return hll ? { count, hll: hllEncode(hll) } : { count };
+  }
   publish(relays, event, params) {
     return relays.map(normalizeURL).map(async (url, i, arr) => {
       if (arr.indexOf(url) !== i) {