@openclaw/nostr 2026.3.13 → 2026.5.2-beta.1

package/src/nostr-bus.integration.test.ts

@@ -1,6 +1,33 @@
 import { describe, expect, it, vi } from "vitest";
 import { createMetrics, createNoopMetrics, type MetricEvent } from "./metrics.js";
 import { createSeenTracker } from "./seen-tracker.js";
+import { TEST_RELAY_URL } from "./test-fixtures.js";
+
+const TEST_RELAY_URL_1 = "wss://relay1.com";
+const TEST_RELAY_URL_2 = "wss://relay2.com";
+const TEST_RELAY_URL_PRIMARY = "wss://relay.com";
+const TEST_RELAY_URL_GOOD = "wss://good-relay.com";
+const TEST_RELAY_URL_BAD = "wss://bad-relay.com";
+
+function createTracker(overrides?: Partial<Parameters<typeof createSeenTracker>[0]>) {
+  return createSeenTracker({
+    maxEntries: 100,
+    ttlMs: 60000,
+    ...overrides,
+  });
+}
+
+function createCollectingMetrics() {
+  const events: MetricEvent[] = [];
+  return {
+    events,
+    metrics: createMetrics((event) => events.push(event)),
+  };
+}
+
+function createPlainMetrics() {
+  return createMetrics();
+}
 
 // ============================================================================
 // Seen Tracker Integration Tests
@@ -9,7 +36,7 @@ import { createSeenTracker } from "./seen-tracker.js";
 describe("SeenTracker", () => {
   describe("basic operations", () => {
     it("tracks seen IDs", () => {
-      const tracker = createSeenTracker({ maxEntries: 100, ttlMs: 60000 });
+      const tracker = createTracker();
 
       // First check returns false and adds
       expect(tracker.has("id1")).toBe(false);
@@ -20,7 +47,7 @@ describe("SeenTracker", () => {
     });
 
     it("peek does not add", () => {
-      const tracker = createSeenTracker({ maxEntries: 100, ttlMs: 60000 });
+      const tracker = createTracker();
 
       expect(tracker.peek("id1")).toBe(false);
       expect(tracker.peek("id1")).toBe(false); // Still false
@@ -32,7 +59,7 @@ describe("SeenTracker", () => {
     });
 
     it("delete removes entries", () => {
-      const tracker = createSeenTracker({ maxEntries: 100, ttlMs: 60000 });
+      const tracker = createTracker();
 
       tracker.add("id1");
       expect(tracker.peek("id1")).toBe(true);
@@ -44,7 +71,7 @@ describe("SeenTracker", () => {
     });
 
     it("clear removes all entries", () => {
-      const tracker = createSeenTracker({ maxEntries: 100, ttlMs: 60000 });
+      const tracker = createTracker();
 
       tracker.add("id1");
       tracker.add("id2");
@@ -59,7 +86,7 @@ describe("SeenTracker", () => {
     });
 
     it("seed pre-populates entries", () => {
-      const tracker = createSeenTracker({ maxEntries: 100, ttlMs: 60000 });
+      const tracker = createTracker();
 
       tracker.seed(["id1", "id2", "id3"]);
       expect(tracker.size()).toBe(3);
@@ -73,7 +100,7 @@ describe("SeenTracker", () => {
 
   describe("LRU eviction", () => {
     it("evicts least recently used when at capacity", () => {
-      const tracker = createSeenTracker({ maxEntries: 3, ttlMs: 60000 });
+      const tracker = createTracker({ maxEntries: 3 });
 
       tracker.add("id1");
       tracker.add("id2");
@@ -92,7 +119,7 @@ describe("SeenTracker", () => {
     });
 
     it("accessing an entry moves it to front (prevents eviction)", () => {
-      const tracker = createSeenTracker({ maxEntries: 3, ttlMs: 60000 });
+      const tracker = createTracker({ maxEntries: 3 });
 
       tracker.add("id1");
       tracker.add("id2");
@@ -112,7 +139,7 @@ describe("SeenTracker", () => {
     });
 
     it("handles capacity of 1", () => {
-      const tracker = createSeenTracker({ maxEntries: 1, ttlMs: 60000 });
+      const tracker = createTracker({ maxEntries: 1 });
 
       tracker.add("id1");
       expect(tracker.peek("id1")).toBe(true);
@@ -125,7 +152,7 @@ describe("SeenTracker", () => {
     });
 
     it("seed respects maxEntries", () => {
-      const tracker = createSeenTracker({ maxEntries: 2, ttlMs: 60000 });
+      const tracker = createTracker({ maxEntries: 2 });
 
       tracker.seed(["id1", "id2", "id3", "id4"]);
       expect(tracker.size()).toBe(2);
@@ -142,7 +169,7 @@ describe("SeenTracker", () => {
     it("expires entries after TTL", async () => {
       vi.useFakeTimers();
 
-      const tracker = createSeenTracker({
+      const tracker = createTracker({
         maxEntries: 100,
         ttlMs: 100,
         pruneIntervalMs: 50,
@@ -164,7 +191,7 @@ describe("SeenTracker", () => {
     it("has() refreshes TTL", async () => {
       vi.useFakeTimers();
 
-      const tracker = createSeenTracker({
+      const tracker = createTracker({
         maxEntries: 100,
         ttlMs: 100,
         pruneIntervalMs: 50,
@@ -197,8 +224,7 @@ describe("SeenTracker", () => {
 describe("Metrics", () => {
   describe("createMetrics", () => {
     it("emits metric events to callback", () => {
-      const events: MetricEvent[] = [];
-      const metrics = createMetrics((event) => events.push(event));
+      const { events, metrics } = createCollectingMetrics();
 
       metrics.emit("event.received");
       metrics.emit("event.processed");
@@ -211,16 +237,15 @@ describe("Metrics", () => {
     });
 
     it("includes labels in metric events", () => {
-      const events: MetricEvent[] = [];
-      const metrics = createMetrics((event) => events.push(event));
+      const { events, metrics } = createCollectingMetrics();
 
-      metrics.emit("relay.connect", 1, { relay: "wss://relay.example.com" });
+      metrics.emit("relay.connect", 1, { relay: TEST_RELAY_URL });
 
-      expect(events[0].labels).toEqual({ relay: "wss://relay.example.com" });
+      expect(events[0].labels).toEqual({ relay: TEST_RELAY_URL });
     });
 
     it("accumulates counters in snapshot", () => {
-      const metrics = createMetrics();
+      const metrics = createPlainMetrics();
 
       metrics.emit("event.received");
       metrics.emit("event.received");
@@ -236,39 +261,39 @@ describe("Metrics", () => {
     });
 
     it("tracks per-relay stats", () => {
-      const metrics = createMetrics();
+      const metrics = createPlainMetrics();
 
-      metrics.emit("relay.connect", 1, { relay: "wss://relay1.com" });
-      metrics.emit("relay.connect", 1, { relay: "wss://relay2.com" });
-      metrics.emit("relay.error", 1, { relay: "wss://relay1.com" });
-      metrics.emit("relay.error", 1, { relay: "wss://relay1.com" });
+      metrics.emit("relay.connect", 1, { relay: TEST_RELAY_URL_1 });
+      metrics.emit("relay.connect", 1, { relay: TEST_RELAY_URL_2 });
+      metrics.emit("relay.error", 1, { relay: TEST_RELAY_URL_1 });
+      metrics.emit("relay.error", 1, { relay: TEST_RELAY_URL_1 });
 
       const snapshot = metrics.getSnapshot();
-      expect(snapshot.relays["wss://relay1.com"]).toBeDefined();
-      expect(snapshot.relays["wss://relay1.com"].connects).toBe(1);
-      expect(snapshot.relays["wss://relay1.com"].errors).toBe(2);
-      expect(snapshot.relays["wss://relay2.com"].connects).toBe(1);
-      expect(snapshot.relays["wss://relay2.com"].errors).toBe(0);
+      expect(snapshot.relays[TEST_RELAY_URL_1]).toBeDefined();
+      expect(snapshot.relays[TEST_RELAY_URL_1].connects).toBe(1);
+      expect(snapshot.relays[TEST_RELAY_URL_1].errors).toBe(2);
+      expect(snapshot.relays[TEST_RELAY_URL_2].connects).toBe(1);
+      expect(snapshot.relays[TEST_RELAY_URL_2].errors).toBe(0);
     });
 
     it("tracks circuit breaker state changes", () => {
-      const metrics = createMetrics();
+      const metrics = createPlainMetrics();
 
-      metrics.emit("relay.circuit_breaker.open", 1, { relay: "wss://relay.com" });
+      metrics.emit("relay.circuit_breaker.open", 1, { relay: TEST_RELAY_URL_PRIMARY });
 
       let snapshot = metrics.getSnapshot();
-      expect(snapshot.relays["wss://relay.com"].circuitBreakerState).toBe("open");
-      expect(snapshot.relays["wss://relay.com"].circuitBreakerOpens).toBe(1);
+      expect(snapshot.relays[TEST_RELAY_URL_PRIMARY].circuitBreakerState).toBe("open");
+      expect(snapshot.relays[TEST_RELAY_URL_PRIMARY].circuitBreakerOpens).toBe(1);
 
-      metrics.emit("relay.circuit_breaker.close", 1, { relay: "wss://relay.com" });
+      metrics.emit("relay.circuit_breaker.close", 1, { relay: TEST_RELAY_URL_PRIMARY });
 
       snapshot = metrics.getSnapshot();
-      expect(snapshot.relays["wss://relay.com"].circuitBreakerState).toBe("closed");
-      expect(snapshot.relays["wss://relay.com"].circuitBreakerCloses).toBe(1);
+      expect(snapshot.relays[TEST_RELAY_URL_PRIMARY].circuitBreakerState).toBe("closed");
+      expect(snapshot.relays[TEST_RELAY_URL_PRIMARY].circuitBreakerCloses).toBe(1);
     });
 
     it("tracks all rejection reasons", () => {
-      const metrics = createMetrics();
+      const metrics = createPlainMetrics();
 
       metrics.emit("event.rejected.invalid_shape");
       metrics.emit("event.rejected.wrong_kind");
@@ -295,17 +320,17 @@ describe("Metrics", () => {
     });
 
     it("tracks relay message types", () => {
-      const metrics = createMetrics();
+      const metrics = createPlainMetrics();
 
-      metrics.emit("relay.message.event", 1, { relay: "wss://relay.com" });
-      metrics.emit("relay.message.eose", 1, { relay: "wss://relay.com" });
-      metrics.emit("relay.message.closed", 1, { relay: "wss://relay.com" });
-      metrics.emit("relay.message.notice", 1, { relay: "wss://relay.com" });
-      metrics.emit("relay.message.ok", 1, { relay: "wss://relay.com" });
-      metrics.emit("relay.message.auth", 1, { relay: "wss://relay.com" });
+      metrics.emit("relay.message.event", 1, { relay: TEST_RELAY_URL_PRIMARY });
+      metrics.emit("relay.message.eose", 1, { relay: TEST_RELAY_URL_PRIMARY });
+      metrics.emit("relay.message.closed", 1, { relay: TEST_RELAY_URL_PRIMARY });
+      metrics.emit("relay.message.notice", 1, { relay: TEST_RELAY_URL_PRIMARY });
+      metrics.emit("relay.message.ok", 1, { relay: TEST_RELAY_URL_PRIMARY });
+      metrics.emit("relay.message.auth", 1, { relay: TEST_RELAY_URL_PRIMARY });
 
       const snapshot = metrics.getSnapshot();
-      const relay = snapshot.relays["wss://relay.com"];
+      const relay = snapshot.relays[TEST_RELAY_URL_PRIMARY];
       expect(relay.messagesReceived.event).toBe(1);
       expect(relay.messagesReceived.eose).toBe(1);
       expect(relay.messagesReceived.closed).toBe(1);
@@ -315,7 +340,7 @@ describe("Metrics", () => {
     });
 
     it("tracks decrypt success/failure", () => {
-      const metrics = createMetrics();
+      const metrics = createPlainMetrics();
 
       metrics.emit("decrypt.success");
       metrics.emit("decrypt.success");
@@ -327,7 +352,7 @@ describe("Metrics", () => {
     });
 
     it("tracks memory gauges (replaces rather than accumulates)", () => {
-      const metrics = createMetrics();
+      const metrics = createPlainMetrics();
 
       metrics.emit("memory.seen_tracker_size", 100);
       metrics.emit("memory.seen_tracker_size", 150);
@@ -338,11 +363,11 @@ describe("Metrics", () => {
     });
 
     it("reset clears all counters", () => {
-      const metrics = createMetrics();
+      const metrics = createPlainMetrics();
 
       metrics.emit("event.received");
       metrics.emit("event.processed");
-      metrics.emit("relay.connect", 1, { relay: "wss://relay.com" });
+      metrics.emit("relay.connect", 1, { relay: TEST_RELAY_URL_PRIMARY });
 
       metrics.reset();
 
@@ -359,7 +384,7 @@ describe("Metrics", () => {
 
       expect(() => {
         metrics.emit("event.received");
-        metrics.emit("relay.connect", 1, { relay: "wss://relay.com" });
+        metrics.emit("relay.connect", 1, { relay: TEST_RELAY_URL_PRIMARY });
       }).not.toThrow();
     });
 
@@ -380,18 +405,17 @@ describe("Metrics", () => {
 describe("Circuit Breaker Behavior", () => {
   // Test the circuit breaker logic through metrics emissions
   it("emits circuit breaker metrics in correct sequence", () => {
-    const events: MetricEvent[] = [];
-    const metrics = createMetrics((event) => events.push(event));
+    const { events, metrics } = createCollectingMetrics();
 
     // Simulate 5 failures -> open
     for (let i = 0; i < 5; i++) {
-      metrics.emit("relay.error", 1, { relay: "wss://relay.com" });
+      metrics.emit("relay.error", 1, { relay: TEST_RELAY_URL_PRIMARY });
     }
-    metrics.emit("relay.circuit_breaker.open", 1, { relay: "wss://relay.com" });
+    metrics.emit("relay.circuit_breaker.open", 1, { relay: TEST_RELAY_URL_PRIMARY });
 
     // Simulate recovery
-    metrics.emit("relay.circuit_breaker.half_open", 1, { relay: "wss://relay.com" });
-    metrics.emit("relay.circuit_breaker.close", 1, { relay: "wss://relay.com" });
+    metrics.emit("relay.circuit_breaker.half_open", 1, { relay: TEST_RELAY_URL_PRIMARY });
+    metrics.emit("relay.circuit_breaker.close", 1, { relay: TEST_RELAY_URL_PRIMARY });
 
     const cbEvents = events.filter((e) => e.name.startsWith("relay.circuit_breaker"));
     expect(cbEvents).toHaveLength(3);
@@ -407,19 +431,19 @@ describe("Circuit Breaker Behavior", () => {
 
 describe("Health Scoring", () => {
   it("metrics track relay errors for health scoring", () => {
-    const metrics = createMetrics();
+    const metrics = createPlainMetrics();
 
     // Simulate mixed success/failure pattern
-    metrics.emit("relay.connect", 1, { relay: "wss://good-relay.com" });
-    metrics.emit("relay.connect", 1, { relay: "wss://bad-relay.com" });
+    metrics.emit("relay.connect", 1, { relay: TEST_RELAY_URL_GOOD });
+    metrics.emit("relay.connect", 1, { relay: TEST_RELAY_URL_BAD });
 
-    metrics.emit("relay.error", 1, { relay: "wss://bad-relay.com" });
-    metrics.emit("relay.error", 1, { relay: "wss://bad-relay.com" });
-    metrics.emit("relay.error", 1, { relay: "wss://bad-relay.com" });
+    metrics.emit("relay.error", 1, { relay: TEST_RELAY_URL_BAD });
+    metrics.emit("relay.error", 1, { relay: TEST_RELAY_URL_BAD });
+    metrics.emit("relay.error", 1, { relay: TEST_RELAY_URL_BAD });
 
     const snapshot = metrics.getSnapshot();
-    expect(snapshot.relays["wss://good-relay.com"].errors).toBe(0);
-    expect(snapshot.relays["wss://bad-relay.com"].errors).toBe(3);
+    expect(snapshot.relays[TEST_RELAY_URL_GOOD].errors).toBe(0);
+    expect(snapshot.relays[TEST_RELAY_URL_BAD].errors).toBe(3);
   });
 });
 
@@ -435,7 +459,7 @@ describe("Reconnect Backoff", () => {
     const JITTER = 0.3;
 
     for (let attempt = 0; attempt < 10; attempt++) {
-      const exponential = BASE * Math.pow(2, attempt);
+      const exponential = BASE * 2 ** attempt;
       const capped = Math.min(exponential, MAX);
       const minDelay = capped * (1 - JITTER);
       const maxDelay = capped * (1 + JITTER);

package/src/nostr-bus.test.ts

@@ -5,27 +5,24 @@ import {
   isValidPubkey,
   normalizePubkey,
   pubkeyToNpub,
-} from "./nostr-bus.js";
-
-// Test private key (DO NOT use in production - this is a known test key)
-const TEST_HEX_KEY = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
-const TEST_NSEC = "nsec1qypqxpq9qtpqscx7peytzfwtdjmcv0mrz5rjpej8vjppfkqfqy8skqfv3l";
+} from "./nostr-key-utils.js";
+import { TEST_HEX_PRIVATE_KEY, TEST_NSEC } from "./test-fixtures.js";
 
 describe("validatePrivateKey", () => {
   describe("hex format", () => {
     it("accepts valid 64-char hex key", () => {
-      const result = validatePrivateKey(TEST_HEX_KEY);
+      const result = validatePrivateKey(TEST_HEX_PRIVATE_KEY);
       expect(result).toBeInstanceOf(Uint8Array);
       expect(result.length).toBe(32);
     });
 
     it("accepts lowercase hex", () => {
-      const result = validatePrivateKey(TEST_HEX_KEY.toLowerCase());
+      const result = validatePrivateKey(TEST_HEX_PRIVATE_KEY.toLowerCase());
       expect(result).toBeInstanceOf(Uint8Array);
     });
 
     it("accepts uppercase hex", () => {
-      const result = validatePrivateKey(TEST_HEX_KEY.toUpperCase());
+      const result = validatePrivateKey(TEST_HEX_PRIVATE_KEY.toUpperCase());
       expect(result).toBeInstanceOf(Uint8Array);
     });
 
@@ -36,23 +33,23 @@ describe("validatePrivateKey", () => {
     });
 
     it("trims whitespace", () => {
-      const result = validatePrivateKey(`  ${TEST_HEX_KEY}  `);
+      const result = validatePrivateKey(`  ${TEST_HEX_PRIVATE_KEY}  `);
       expect(result).toBeInstanceOf(Uint8Array);
     });
 
     it("trims newlines", () => {
-      const result = validatePrivateKey(`${TEST_HEX_KEY}\n`);
+      const result = validatePrivateKey(`${TEST_HEX_PRIVATE_KEY}\n`);
       expect(result).toBeInstanceOf(Uint8Array);
     });
 
     it("rejects 63-char hex (too short)", () => {
-      expect(() => validatePrivateKey(TEST_HEX_KEY.slice(0, 63))).toThrow(
+      expect(() => validatePrivateKey(TEST_HEX_PRIVATE_KEY.slice(0, 63))).toThrow(
         "Private key must be 64 hex characters",
       );
     });
 
     it("rejects 65-char hex (too long)", () => {
-      expect(() => validatePrivateKey(TEST_HEX_KEY + "0")).toThrow(
+      expect(() => validatePrivateKey(TEST_HEX_PRIVATE_KEY + "0")).toThrow(
         "Private key must be 64 hex characters",
       );
     });
@@ -71,7 +68,7 @@ describe("validatePrivateKey", () => {
     });
 
     it("rejects key with 0x prefix", () => {
-      expect(() => validatePrivateKey("0x" + TEST_HEX_KEY)).toThrow(
+      expect(() => validatePrivateKey("0x" + TEST_HEX_PRIVATE_KEY)).toThrow(
         "Private key must be 64 hex characters",
       );
     });
@@ -93,8 +90,7 @@ describe("validatePrivateKey", () => {
 describe("isValidPubkey", () => {
   describe("hex format", () => {
     it("accepts valid 64-char hex pubkey", () => {
-      const validHex = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
-      expect(isValidPubkey(validHex)).toBe(true);
+      expect(isValidPubkey(TEST_HEX_PRIVATE_KEY)).toBe(true);
     });
 
     it("accepts uppercase hex", () => {
@@ -108,7 +104,7 @@ describe("isValidPubkey", () => {
     });
 
     it("rejects 65-char hex", () => {
-      const longHex = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0";
+      const longHex = `${TEST_HEX_PRIVATE_KEY}0`;
       expect(isValidPubkey(longHex)).toBe(false);
     });
 
@@ -134,8 +130,7 @@ describe("isValidPubkey", () => {
     });
 
     it("handles whitespace-padded input", () => {
-      const validHex = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
-      expect(isValidPubkey(`  ${validHex}  `)).toBe(true);
+      expect(isValidPubkey(`  ${TEST_HEX_PRIVATE_KEY}  `)).toBe(true);
     });
   });
 });
@@ -149,8 +144,7 @@ describe("normalizePubkey", () => {
     });
 
     it("trims whitespace", () => {
-      const hex = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
-      expect(normalizePubkey(`  ${hex}  `)).toBe(hex);
+      expect(normalizePubkey(`  ${TEST_HEX_PRIVATE_KEY}  `)).toBe(TEST_HEX_PRIVATE_KEY);
     });
 
     it("rejects invalid hex", () => {
@@ -161,14 +155,14 @@ describe("normalizePubkey", () => {
 
 describe("getPublicKeyFromPrivate", () => {
   it("derives public key from hex private key", () => {
-    const pubkey = getPublicKeyFromPrivate(TEST_HEX_KEY);
+    const pubkey = getPublicKeyFromPrivate(TEST_HEX_PRIVATE_KEY);
     expect(pubkey).toMatch(/^[0-9a-f]{64}$/);
     expect(pubkey.length).toBe(64);
   });
 
   it("derives consistent public key", () => {
-    const pubkey1 = getPublicKeyFromPrivate(TEST_HEX_KEY);
-    const pubkey2 = getPublicKeyFromPrivate(TEST_HEX_KEY);
+    const pubkey1 = getPublicKeyFromPrivate(TEST_HEX_PRIVATE_KEY);
+    const pubkey2 = getPublicKeyFromPrivate(TEST_HEX_PRIVATE_KEY);
     expect(pubkey1).toBe(pubkey2);
   });
 
@@ -179,21 +173,18 @@ describe("getPublicKeyFromPrivate", () => {
 
 describe("pubkeyToNpub", () => {
   it("converts hex pubkey to npub format", () => {
-    const hex = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
-    const npub = pubkeyToNpub(hex);
+    const npub = pubkeyToNpub(TEST_HEX_PRIVATE_KEY);
     expect(npub).toMatch(/^npub1[a-z0-9]+$/);
   });
 
   it("produces consistent output", () => {
-    const hex = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
-    const npub1 = pubkeyToNpub(hex);
-    const npub2 = pubkeyToNpub(hex);
+    const npub1 = pubkeyToNpub(TEST_HEX_PRIVATE_KEY);
+    const npub2 = pubkeyToNpub(TEST_HEX_PRIVATE_KEY);
     expect(npub1).toBe(npub2);
   });
 
   it("normalizes uppercase hex first", () => {
-    const lower = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
-    const upper = lower.toUpperCase();
-    expect(pubkeyToNpub(lower)).toBe(pubkeyToNpub(upper));
+    const upper = TEST_HEX_PRIVATE_KEY.toUpperCase();
+    expect(pubkeyToNpub(TEST_HEX_PRIVATE_KEY)).toBe(pubkeyToNpub(upper));
   });
 });