openclaw-nostr 2026.7.30

package/src/nostr-discovery.test.ts

@@ -0,0 +1,568 @@
+/**
+ * Tests for Nostr Discovery — NIP-05, NIP-11, NIP-27
+ *
+ * NIP-05: identity resolution with caching
+ * NIP-11: relay info with caching
+ * NIP-27: content block parsing
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// ============================================================================
+// Mocks
+// ============================================================================
+
+// Mock nostr-tools/nip05
+const mockQueryProfile = vi.fn();
+const mockSearchDomain = vi.fn();
+const mockIsValid = vi.fn();
+const mockIsNip05 = vi.fn();
+
+vi.mock("nostr-tools/nip05", () => ({
+  queryProfile: (...args: unknown[]) => mockQueryProfile(...args),
+  searchDomain: (...args: unknown[]) => mockSearchDomain(...args),
+  isValid: (...args: unknown[]) => mockIsValid(...args),
+  isNip05: (...args: unknown[]) => mockIsNip05(...args),
+  NIP05_REGEX: /^(?:[a-z0-9._-]+@)?[a-z0-9.-]+\.[a-z]{2,}$/i,
+}));
+
+// Mock nostr-tools/nip11
+const mockFetchRelayInformation = vi.fn();
+
+vi.mock("nostr-tools/nip11", () => ({
+  fetchRelayInformation: (...args: unknown[]) => mockFetchRelayInformation(...args),
+}));
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe("NIP-05: Identity Resolution", () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    // Clear cache between tests
+    const { clearNip05CacheForTest } = await import("./nostr-discovery.js");
+    clearNip05CacheForTest();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("resolveNip05", () => {
+    it("resolves a valid NIP-05 address to pubkey and relays", async () => {
+      const { resolveNip05 } = await import("./nostr-discovery.js");
+
+      mockQueryProfile.mockResolvedValueOnce({
+        pubkey: "aabbccdd".repeat(8),
+        relays: ["wss://relay1.example", "wss://relay2.example"],
+      });
+
+      const result = await resolveNip05("alice@example.com");
+
+      expect(result).not.toBeNull();
+      expect(result!.nip05).toBe("alice@example.com");
+      expect(result!.pubkey).toBe("aabbccdd".repeat(8));
+      expect(result!.relays).toEqual(["wss://relay1.example", "wss://relay2.example"]);
+      expect(mockQueryProfile).toHaveBeenCalledWith("alice@example.com");
+    });
+
+    it("normalizes the address (trim + lowercase)", async () => {
+      const { resolveNip05 } = await import("./nostr-discovery.js");
+
+      mockQueryProfile.mockResolvedValueOnce({
+        pubkey: "aabbccdd".repeat(8),
+        relays: [],
+      });
+
+      const result = await resolveNip05("  Alice@Example.COM  ");
+
+      expect(result).not.toBeNull();
+      expect(result!.nip05).toBe("alice@example.com");
+      expect(mockQueryProfile).toHaveBeenCalledWith("alice@example.com");
+    });
+
+    it("returns null for empty string", async () => {
+      const { resolveNip05 } = await import("./nostr-discovery.js");
+      const result = await resolveNip05("");
+      expect(result).toBeNull();
+      expect(mockQueryProfile).not.toHaveBeenCalled();
+    });
+
+    it("returns null for whitespace-only string", async () => {
+      const { resolveNip05 } = await import("./nostr-discovery.js");
+      const result = await resolveNip05("   ");
+      expect(result).toBeNull();
+      expect(mockQueryProfile).not.toHaveBeenCalled();
+    });
+
+    it("returns null when profile has no pubkey", async () => {
+      const { resolveNip05 } = await import("./nostr-discovery.js");
+      mockQueryProfile.mockResolvedValueOnce({ pubkey: null, relays: [] });
+
+      const result = await resolveNip05("nobody@example.com");
+      expect(result).toBeNull();
+    });
+
+    it("returns null when queryProfile returns null", async () => {
+      const { resolveNip05 } = await import("./nostr-discovery.js");
+      mockQueryProfile.mockResolvedValueOnce(null);
+
+      const result = await resolveNip05("unknown@example.com");
+      expect(result).toBeNull();
+    });
+
+    it("handles empty relays array", async () => {
+      const { resolveNip05 } = await import("./nostr-discovery.js");
+      mockQueryProfile.mockResolvedValueOnce({
+        pubkey: "aabbccdd".repeat(8),
+        relays: undefined,
+      });
+
+      const result = await resolveNip05("alice@example.com");
+      expect(result).not.toBeNull();
+      expect(result!.relays).toEqual([]);
+    });
+
+    it("returns null on network error without caching the failure", async () => {
+      const { resolveNip05 } = await import("./nostr-discovery.js");
+      mockQueryProfile.mockRejectedValueOnce(new Error("Network error"));
+
+      const result1 = await resolveNip05("alice@example.com");
+      expect(result1).toBeNull();
+
+      // Second call should retry (not use cached failure)
+      mockQueryProfile.mockResolvedValueOnce({
+        pubkey: "aabbccdd".repeat(8),
+        relays: [],
+      });
+
+      const result2 = await resolveNip05("alice@example.com");
+      expect(result2).not.toBeNull();
+      expect(result2!.pubkey).toBe("aabbccdd".repeat(8));
+      expect(mockQueryProfile).toHaveBeenCalledTimes(2);
+    });
+
+    it("caches successful results", async () => {
+      const { resolveNip05 } = await import("./nostr-discovery.js");
+      mockQueryProfile.mockResolvedValueOnce({
+        pubkey: "aabbccdd".repeat(8),
+        relays: ["wss://relay.example"],
+      });
+
+      const result1 = await resolveNip05("alice@example.com");
+      const result2 = await resolveNip05("alice@example.com");
+
+      expect(result1).toEqual(result2);
+      // Should only call the network once
+      expect(mockQueryProfile).toHaveBeenCalledTimes(1);
+    });
+
+    it("caches null results (not found)", async () => {
+      const { resolveNip05 } = await import("./nostr-discovery.js");
+      mockQueryProfile.mockResolvedValueOnce(null);
+
+      const result1 = await resolveNip05("nobody@example.com");
+      const result2 = await resolveNip05("nobody@example.com");
+
+      expect(result1).toBeNull();
+      expect(result2).toBeNull();
+      expect(mockQueryProfile).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("searchNip05Domain", () => {
+    it("returns name→pubkey map from a domain", async () => {
+      const { searchNip05Domain } = await import("./nostr-discovery.js");
+      mockSearchDomain.mockResolvedValueOnce({
+        alice: "aabbccdd".repeat(8),
+        bob: "11223344".repeat(8),
+      });
+
+      const result = await searchNip05Domain("example.com", "a");
+      expect(result).toEqual({
+        alice: "aabbccdd".repeat(8),
+        bob: "11223344".repeat(8),
+      });
+      expect(mockSearchDomain).toHaveBeenCalledWith("example.com", "a");
+    });
+
+    it("returns empty object on error", async () => {
+      const { searchNip05Domain } = await import("./nostr-discovery.js");
+      mockSearchDomain.mockRejectedValueOnce(new Error("DNS failure"));
+
+      const result = await searchNip05Domain("example.com");
+      expect(result).toEqual({});
+    });
+
+    it("defaults to empty query string", async () => {
+      const { searchNip05Domain } = await import("./nostr-discovery.js");
+      mockSearchDomain.mockResolvedValueOnce({});
+
+      await searchNip05Domain("example.com");
+      expect(mockSearchDomain).toHaveBeenCalledWith("example.com", "");
+    });
+  });
+
+  describe("validateNip05", () => {
+    it("returns true when pubkey matches address", async () => {
+      const { validateNip05 } = await import("./nostr-discovery.js");
+      const pubkey = "aabbccdd".repeat(8);
+      mockIsValid.mockResolvedValueOnce(true);
+
+      const result = await validateNip05(pubkey, "alice@example.com");
+      expect(result).toBe(true);
+    });
+
+    it("returns false when validation fails", async () => {
+      const { validateNip05 } = await import("./nostr-discovery.js");
+      mockIsValid.mockResolvedValueOnce(false);
+
+      const result = await validateNip05("wrongpubkey".repeat(6), "alice@example.com");
+      expect(result).toBe(false);
+    });
+
+    it("returns false on error", async () => {
+      const { validateNip05 } = await import("./nostr-discovery.js");
+      mockIsValid.mockRejectedValueOnce(new Error("Network error"));
+
+      const result = await validateNip05("aabbccdd".repeat(8), "alice@example.com");
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("isNip05Address", () => {
+    it("delegates to nostr-tools isNip05", async () => {
+      const { isNip05Address } = await import("./nostr-discovery.js");
+      mockIsNip05.mockReturnValueOnce(true);
+
+      const result = isNip05Address("alice@example.com");
+      expect(result).toBe(true);
+      expect(mockIsNip05).toHaveBeenCalledWith("alice@example.com");
+    });
+
+    it("returns false for non-NIP-05 strings", async () => {
+      const { isNip05Address } = await import("./nostr-discovery.js");
+      mockIsNip05.mockReturnValueOnce(false);
+
+      const result = isNip05Address("not-a-nip05");
+      expect(result).toBe(false);
+    });
+  });
+});
+
+describe("NIP-11: Relay Information", () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    const { clearNip11CacheForTest } = await import("./nostr-discovery.js");
+    clearNip11CacheForTest();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  const sampleRelayInfo = {
+    name: "Test Relay",
+    description: "A test relay",
+    pubkey: "aabbccdd".repeat(8),
+    contact: "admin@example.com",
+    supported_nips: [1, 4, 11, 17, 42],
+    software: "test-relay",
+    version: "1.0.0",
+    limitation: {
+      auth_required: false,
+      payment_required: false,
+      max_message_length: 16384,
+      max_content_length: 8196,
+      min_pow_difficulty: 0,
+      restricted_writes: false,
+    },
+  };
+
+  describe("fetchRelayInfo", () => {
+    it("fetches and returns relay information", async () => {
+      const { fetchRelayInfo } = await import("./nostr-discovery.js");
+      mockFetchRelayInformation.mockResolvedValueOnce(sampleRelayInfo);
+
+      const result = await fetchRelayInfo("wss://relay.example");
+      expect(result).toEqual(sampleRelayInfo);
+    });
+
+    it("normalizes relay URL (trailing slash)", async () => {
+      const { fetchRelayInfo } = await import("./nostr-discovery.js");
+      mockFetchRelayInformation.mockResolvedValueOnce(sampleRelayInfo);
+
+      await fetchRelayInfo("wss://relay.example");
+      expect(mockFetchRelayInformation).toHaveBeenCalledWith("wss://relay.example/");
+    });
+
+    it("handles URL already having trailing slash", async () => {
+      const { fetchRelayInfo } = await import("./nostr-discovery.js");
+      mockFetchRelayInformation.mockResolvedValueOnce(sampleRelayInfo);
+
+      await fetchRelayInfo("wss://relay.example/");
+      expect(mockFetchRelayInformation).toHaveBeenCalledWith("wss://relay.example/");
+    });
+
+    it("returns null on network error", async () => {
+      const { fetchRelayInfo } = await import("./nostr-discovery.js");
+      mockFetchRelayInformation.mockRejectedValueOnce(new Error("Connection refused"));
+
+      const result = await fetchRelayInfo("wss://offline.example");
+      expect(result).toBeNull();
+    });
+
+    it("caches successful results", async () => {
+      const { fetchRelayInfo } = await import("./nostr-discovery.js");
+      mockFetchRelayInformation.mockResolvedValueOnce(sampleRelayInfo);
+
+      const result1 = await fetchRelayInfo("wss://relay.example");
+      const result2 = await fetchRelayInfo("wss://relay.example");
+
+      expect(result1).toEqual(result2);
+      expect(mockFetchRelayInformation).toHaveBeenCalledTimes(1);
+    });
+
+    it("caches with normalized URL (with/without trailing slash hit same entry)", async () => {
+      const { fetchRelayInfo } = await import("./nostr-discovery.js");
+      mockFetchRelayInformation.mockResolvedValueOnce(sampleRelayInfo);
+
+      await fetchRelayInfo("wss://relay.example");
+      await fetchRelayInfo("wss://relay.example/");
+
+      // Both should normalize to the same cache key
+      expect(mockFetchRelayInformation).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("getRelayCapabilities", () => {
+    it("distills full relay info into capability summary", async () => {
+      const { getRelayCapabilities } = await import("./nostr-discovery.js");
+      mockFetchRelayInformation.mockResolvedValueOnce(sampleRelayInfo);
+
+      const result = await getRelayCapabilities("wss://relay.example");
+      expect(result).not.toBeNull();
+      expect(result!.url).toBe("wss://relay.example");
+      expect(result!.name).toBe("Test Relay");
+      expect(result!.description).toBe("A test relay");
+      expect(result!.supportedNips).toEqual([1, 4, 11, 17, 42]);
+      expect(result!.authRequired).toBe(false);
+      expect(result!.paymentRequired).toBe(false);
+      expect(result!.maxMessageLength).toBe(16384);
+      expect(result!.maxContentLength).toBe(8196);
+      expect(result!.minPowDifficulty).toBe(0);
+      expect(result!.restrictedWrites).toBe(false);
+    });
+
+    it("returns null when relay info fetch fails", async () => {
+      const { getRelayCapabilities } = await import("./nostr-discovery.js");
+      mockFetchRelayInformation.mockRejectedValueOnce(new Error("Fail"));
+
+      const result = await getRelayCapabilities("wss://offline.example");
+      expect(result).toBeNull();
+    });
+
+    it("handles relay info without limitation field", async () => {
+      const { getRelayCapabilities } = await import("./nostr-discovery.js");
+      mockFetchRelayInformation.mockResolvedValueOnce({
+        name: "Basic Relay",
+        supported_nips: [1],
+      });
+
+      const result = await getRelayCapabilities("wss://basic.example");
+      expect(result).not.toBeNull();
+      expect(result!.authRequired).toBe(false);
+      expect(result!.paymentRequired).toBe(false);
+      expect(result!.restrictedWrites).toBe(false);
+      expect(result!.maxMessageLength).toBeUndefined();
+    });
+
+    it("handles relay info with auth required", async () => {
+      const { getRelayCapabilities } = await import("./nostr-discovery.js");
+      mockFetchRelayInformation.mockResolvedValueOnce({
+        name: "Auth Relay",
+        supported_nips: [1, 42],
+        limitation: {
+          auth_required: true,
+          payment_required: false,
+          restricted_writes: true,
+          min_pow_difficulty: 16,
+        },
+      });
+
+      const result = await getRelayCapabilities("wss://auth.example");
+      expect(result!.authRequired).toBe(true);
+      expect(result!.restrictedWrites).toBe(true);
+      expect(result!.minPowDifficulty).toBe(16);
+    });
+  });
+
+  describe("relaySupportsNip", () => {
+    it("returns true when relay supports the NIP", async () => {
+      const { relaySupportsNip } = await import("./nostr-discovery.js");
+      mockFetchRelayInformation.mockResolvedValueOnce(sampleRelayInfo);
+
+      expect(await relaySupportsNip("wss://relay.example", 42)).toBe(true);
+    });
+
+    it("returns false when relay does not support the NIP", async () => {
+      const { relaySupportsNip } = await import("./nostr-discovery.js");
+      mockFetchRelayInformation.mockResolvedValueOnce(sampleRelayInfo);
+
+      expect(await relaySupportsNip("wss://relay.example", 99)).toBe(false);
+    });
+
+    it("returns false when relay info unavailable", async () => {
+      const { relaySupportsNip } = await import("./nostr-discovery.js");
+      mockFetchRelayInformation.mockRejectedValueOnce(new Error("Fail"));
+
+      expect(await relaySupportsNip("wss://offline.example", 1)).toBe(false);
+    });
+  });
+
+  describe("filterRelaysByNip", () => {
+    it("returns only relays that support the specified NIP", async () => {
+      const { filterRelaysByNip } = await import("./nostr-discovery.js");
+
+      // Relay 1: supports NIP-42
+      mockFetchRelayInformation.mockResolvedValueOnce({
+        supported_nips: [1, 42],
+      });
+      // Relay 2: does not support NIP-42
+      mockFetchRelayInformation.mockResolvedValueOnce({
+        supported_nips: [1, 4],
+      });
+      // Relay 3: supports NIP-42
+      mockFetchRelayInformation.mockResolvedValueOnce({
+        supported_nips: [1, 11, 42],
+      });
+
+      const result = await filterRelaysByNip(
+        ["wss://relay1.example", "wss://relay2.example", "wss://relay3.example"],
+        42,
+      );
+
+      expect(result).toEqual(["wss://relay1.example", "wss://relay3.example"]);
+    });
+
+    it("returns empty array when no relays support the NIP", async () => {
+      const { filterRelaysByNip } = await import("./nostr-discovery.js");
+
+      mockFetchRelayInformation.mockResolvedValueOnce({ supported_nips: [1] });
+      mockFetchRelayInformation.mockResolvedValueOnce({ supported_nips: [1] });
+
+      const result = await filterRelaysByNip(
+        ["wss://relay1.example", "wss://relay2.example"],
+        99,
+      );
+      expect(result).toEqual([]);
+    });
+
+    it("handles failed relay lookups gracefully", async () => {
+      const { filterRelaysByNip } = await import("./nostr-discovery.js");
+
+      mockFetchRelayInformation.mockResolvedValueOnce({ supported_nips: [1, 42] });
+      mockFetchRelayInformation.mockRejectedValueOnce(new Error("Offline"));
+
+      const result = await filterRelaysByNip(
+        ["wss://relay1.example", "wss://offline.example"],
+        42,
+      );
+      expect(result).toEqual(["wss://relay1.example"]);
+    });
+
+    it("returns empty array for empty input", async () => {
+      const { filterRelaysByNip } = await import("./nostr-discovery.js");
+      const result = await filterRelaysByNip([], 42);
+      expect(result).toEqual([]);
+    });
+  });
+});
+
+describe("NIP-27: Content Parsing", () => {
+  // NIP-27 tests use the real nostr-tools parser (no mocks needed)
+
+  describe("parseContentBlocks", () => {
+    it("parses plain text", async () => {
+      const { parseContentBlocks } = await import("./nostr-discovery.js");
+      const blocks = parseContentBlocks("Hello, world!");
+
+      expect(blocks.length).toBeGreaterThan(0);
+      expect(blocks[0].type).toBe("text");
+      if (blocks[0].type === "text") {
+        // nostr-tools nip27 uses .text for text blocks
+        expect((blocks[0] as any).text).toBe("Hello, world!");
+      }
+    });
+
+    it("parses URLs in content", async () => {
+      const { parseContentBlocks } = await import("./nostr-discovery.js");
+      const blocks = parseContentBlocks("Check out https://example.com for more");
+
+      const urlBlocks = blocks.filter((b) => b.type === "url");
+      expect(urlBlocks.length).toBe(1);
+    });
+
+    it("parses nostr: references", async () => {
+      const { parseContentBlocks } = await import("./nostr-discovery.js");
+      const npub = "npub1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3x9j7s";
+      const blocks = parseContentBlocks(`Hello nostr:${npub}`);
+
+      // nostr-tools v2.23.3 nip27 parser may inline references into text blocks
+      // rather than emitting separate "reference" blocks. Verify the content
+      // round-trips through the parser without loss.
+      const allText = blocks.map((b: any) => b.text ?? b.decoded?.value ?? "").join("");
+      expect(allText).toContain(npub);
+      expect(blocks.length).toBeGreaterThan(0);
+    });
+
+    it("parses hashtags in content", async () => {
+      const { parseContentBlocks } = await import("./nostr-discovery.js");
+      const blocks = parseContentBlocks("Hello #nostr #bitcoin world");
+
+      const hashtagBlocks = blocks.filter((b) => b.type === "hashtag");
+      expect(hashtagBlocks.length).toBe(2);
+    });
+
+    it("handles empty string", async () => {
+      const { parseContentBlocks } = await import("./nostr-discovery.js");
+      const blocks = parseContentBlocks("");
+      // Empty string should produce either no blocks or a single empty text block
+      expect(blocks.length).toBeLessThanOrEqual(1);
+    });
+
+    it("parses mixed content with text, URLs, and references", async () => {
+      const { parseContentBlocks } = await import("./nostr-discovery.js");
+      const content = "Hello https://example.com #nostr";
+      const blocks = parseContentBlocks(content);
+
+      // Should have at least text + url + hashtag
+      const types = blocks.map((b) => b.type);
+      expect(types).toContain("text");
+      expect(types).toContain("url");
+      expect(types).toContain("hashtag");
+    });
+
+    it("parses image URLs", async () => {
+      const { parseContentBlocks } = await import("./nostr-discovery.js");
+      const blocks = parseContentBlocks("Look at this https://example.com/photo.jpg");
+
+      // Image URLs should be parsed as image or url type
+      const mediaBlocks = blocks.filter(
+        (b) => b.type === "image" || b.type === "url",
+      );
+      expect(mediaBlocks.length).toBeGreaterThan(0);
+    });
+
+    it("parseContent generator yields same blocks as parseContentBlocks", async () => {
+      const { parseContent, parseContentBlocks } = await import("./nostr-discovery.js");
+      const content = "Hello https://example.com #test";
+
+      const blocksFromArray = parseContentBlocks(content);
+      const blocksFromGenerator = [...parseContent(content)];
+
+      expect(blocksFromArray).toEqual(blocksFromGenerator);
+    });
+  });
+});