@kodelyth/nostr 2026.5.42 → 2026.6.2

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

@@ -1,477 +0,0 @@
-import { afterEach, 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";
-
-afterEach(() => {
-  vi.useRealTimers();
-});
-
-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
-// ============================================================================
-
-describe("SeenTracker", () => {
-  describe("basic operations", () => {
-    it("tracks seen IDs", () => {
-      const tracker = createTracker();
-
-      // First check returns false and adds
-      expect(tracker.has("id1")).toBe(false);
-      // Second check returns true (already seen)
-      expect(tracker.has("id1")).toBe(true);
-
-      tracker.stop();
-    });
-
-    it("peek does not add", () => {
-      const tracker = createTracker();
-
-      expect(tracker.peek("id1")).toBe(false);
-      expect(tracker.peek("id1")).toBe(false); // Still false
-
-      tracker.add("id1");
-      expect(tracker.peek("id1")).toBe(true);
-
-      tracker.stop();
-    });
-
-    it("delete removes entries", () => {
-      const tracker = createTracker();
-
-      tracker.add("id1");
-      expect(tracker.peek("id1")).toBe(true);
-
-      tracker.delete("id1");
-      expect(tracker.peek("id1")).toBe(false);
-
-      tracker.stop();
-    });
-
-    it("clear removes all entries", () => {
-      const tracker = createTracker();
-
-      tracker.add("id1");
-      tracker.add("id2");
-      tracker.add("id3");
-      expect(tracker.size()).toBe(3);
-
-      tracker.clear();
-      expect(tracker.size()).toBe(0);
-      expect(tracker.peek("id1")).toBe(false);
-
-      tracker.stop();
-    });
-
-    it("seed pre-populates entries", () => {
-      const tracker = createTracker();
-
-      tracker.seed(["id1", "id2", "id3"]);
-      expect(tracker.size()).toBe(3);
-      expect(tracker.peek("id1")).toBe(true);
-      expect(tracker.peek("id2")).toBe(true);
-      expect(tracker.peek("id3")).toBe(true);
-
-      tracker.stop();
-    });
-  });
-
-  describe("LRU eviction", () => {
-    it("evicts least recently used when at capacity", () => {
-      const tracker = createTracker({ maxEntries: 3 });
-
-      tracker.add("id1");
-      tracker.add("id2");
-      tracker.add("id3");
-      expect(tracker.size()).toBe(3);
-
-      // Adding fourth should evict oldest (id1)
-      tracker.add("id4");
-      expect(tracker.size()).toBe(3);
-      expect(tracker.peek("id1")).toBe(false); // Evicted
-      expect(tracker.peek("id2")).toBe(true);
-      expect(tracker.peek("id3")).toBe(true);
-      expect(tracker.peek("id4")).toBe(true);
-
-      tracker.stop();
-    });
-
-    it("accessing an entry moves it to front (prevents eviction)", () => {
-      const tracker = createTracker({ maxEntries: 3 });
-
-      tracker.add("id1");
-      tracker.add("id2");
-      tracker.add("id3");
-
-      // Access id1, moving it to front
-      tracker.has("id1");
-
-      // Add id4 - should evict id2 (now oldest)
-      tracker.add("id4");
-      expect(tracker.peek("id1")).toBe(true); // Not evicted, was accessed
-      expect(tracker.peek("id2")).toBe(false); // Evicted
-      expect(tracker.peek("id3")).toBe(true);
-      expect(tracker.peek("id4")).toBe(true);
-
-      tracker.stop();
-    });
-
-    it("handles capacity of 1", () => {
-      const tracker = createTracker({ maxEntries: 1 });
-
-      tracker.add("id1");
-      expect(tracker.peek("id1")).toBe(true);
-
-      tracker.add("id2");
-      expect(tracker.peek("id1")).toBe(false);
-      expect(tracker.peek("id2")).toBe(true);
-
-      tracker.stop();
-    });
-
-    it("seed respects maxEntries", () => {
-      const tracker = createTracker({ maxEntries: 2 });
-
-      tracker.seed(["id1", "id2", "id3", "id4"]);
-      expect(tracker.size()).toBe(2);
-      // Seed stops when maxEntries reached, processing from end to start
-      // So id4 and id3 get added first, then we're at capacity
-      expect(tracker.peek("id3")).toBe(true);
-      expect(tracker.peek("id4")).toBe(true);
-
-      tracker.stop();
-    });
-  });
-
-  describe("TTL expiration", () => {
-    it("expires entries after TTL", () => {
-      vi.useFakeTimers();
-
-      const tracker = createTracker({
-        maxEntries: 100,
-        ttlMs: 100,
-        pruneIntervalMs: 50,
-      });
-
-      tracker.add("id1");
-      expect(tracker.peek("id1")).toBe(true);
-
-      // Advance past TTL
-      vi.advanceTimersByTime(150);
-
-      // Entry should be expired
-      expect(tracker.peek("id1")).toBe(false);
-
-      tracker.stop();
-      vi.useRealTimers();
-    });
-
-    it("has() refreshes TTL", () => {
-      vi.useFakeTimers();
-
-      const tracker = createTracker({
-        maxEntries: 100,
-        ttlMs: 100,
-        pruneIntervalMs: 50,
-      });
-
-      tracker.add("id1");
-
-      // Advance halfway
-      vi.advanceTimersByTime(50);
-
-      // Access to refresh
-      expect(tracker.has("id1")).toBe(true);
-
-      // Advance another 75ms (total 125ms from add, but only 75ms from last access)
-      vi.advanceTimersByTime(75);
-
-      // Should still be valid (refreshed at 50ms)
-      expect(tracker.peek("id1")).toBe(true);
-
-      tracker.stop();
-      vi.useRealTimers();
-    });
-  });
-});
-
-// ============================================================================
-// Metrics Integration Tests
-// ============================================================================
-
-describe("Metrics", () => {
-  describe("createMetrics", () => {
-    it("emits metric events to callback", () => {
-      const { events, metrics } = createCollectingMetrics();
-
-      metrics.emit("event.received");
-      metrics.emit("event.processed");
-      metrics.emit("event.duplicate");
-
-      expect(events).toHaveLength(3);
-      expect(events[0].name).toBe("event.received");
-      expect(events[1].name).toBe("event.processed");
-      expect(events[2].name).toBe("event.duplicate");
-    });
-
-    it("includes labels in metric events", () => {
-      const { events, metrics } = createCollectingMetrics();
-
-      metrics.emit("relay.connect", 1, { relay: TEST_RELAY_URL });
-
-      expect(events[0].labels).toEqual({ relay: TEST_RELAY_URL });
-    });
-
-    it("accumulates counters in snapshot", () => {
-      const metrics = createPlainMetrics();
-
-      metrics.emit("event.received");
-      metrics.emit("event.received");
-      metrics.emit("event.processed");
-      metrics.emit("event.duplicate");
-      metrics.emit("event.duplicate");
-      metrics.emit("event.duplicate");
-
-      const snapshot = metrics.getSnapshot();
-      expect(snapshot.eventsReceived).toBe(2);
-      expect(snapshot.eventsProcessed).toBe(1);
-      expect(snapshot.eventsDuplicate).toBe(3);
-    });
-
-    it("tracks per-relay stats", () => {
-      const metrics = createPlainMetrics();
-
-      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();
-      const relayOne = snapshot.relays[TEST_RELAY_URL_1];
-      if (!relayOne) {
-        throw new Error("expected first relay metrics");
-      }
-      expect(relayOne.connects).toBe(1);
-      expect(relayOne.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 = createPlainMetrics();
-
-      metrics.emit("relay.circuit_breaker.open", 1, { relay: TEST_RELAY_URL_PRIMARY });
-
-      let snapshot = metrics.getSnapshot();
-      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: TEST_RELAY_URL_PRIMARY });
-
-      snapshot = metrics.getSnapshot();
-      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 = createPlainMetrics();
-
-      metrics.emit("event.rejected.invalid_shape");
-      metrics.emit("event.rejected.wrong_kind");
-      metrics.emit("event.rejected.stale");
-      metrics.emit("event.rejected.future");
-      metrics.emit("event.rejected.rate_limited");
-      metrics.emit("event.rejected.invalid_signature");
-      metrics.emit("event.rejected.oversized_ciphertext");
-      metrics.emit("event.rejected.oversized_plaintext");
-      metrics.emit("event.rejected.decrypt_failed");
-      metrics.emit("event.rejected.self_message");
-
-      const snapshot = metrics.getSnapshot();
-      expect(snapshot.eventsRejected.invalidShape).toBe(1);
-      expect(snapshot.eventsRejected.wrongKind).toBe(1);
-      expect(snapshot.eventsRejected.stale).toBe(1);
-      expect(snapshot.eventsRejected.future).toBe(1);
-      expect(snapshot.eventsRejected.rateLimited).toBe(1);
-      expect(snapshot.eventsRejected.invalidSignature).toBe(1);
-      expect(snapshot.eventsRejected.oversizedCiphertext).toBe(1);
-      expect(snapshot.eventsRejected.oversizedPlaintext).toBe(1);
-      expect(snapshot.eventsRejected.decryptFailed).toBe(1);
-      expect(snapshot.eventsRejected.selfMessage).toBe(1);
-    });
-
-    it("tracks relay message types", () => {
-      const metrics = createPlainMetrics();
-
-      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[TEST_RELAY_URL_PRIMARY];
-      expect(relay.messagesReceived.event).toBe(1);
-      expect(relay.messagesReceived.eose).toBe(1);
-      expect(relay.messagesReceived.closed).toBe(1);
-      expect(relay.messagesReceived.notice).toBe(1);
-      expect(relay.messagesReceived.ok).toBe(1);
-      expect(relay.messagesReceived.auth).toBe(1);
-    });
-
-    it("tracks decrypt success/failure", () => {
-      const metrics = createPlainMetrics();
-
-      metrics.emit("decrypt.success");
-      metrics.emit("decrypt.success");
-      metrics.emit("decrypt.failure");
-
-      const snapshot = metrics.getSnapshot();
-      expect(snapshot.decrypt.success).toBe(2);
-      expect(snapshot.decrypt.failure).toBe(1);
-    });
-
-    it("tracks memory gauges (replaces rather than accumulates)", () => {
-      const metrics = createPlainMetrics();
-
-      metrics.emit("memory.seen_tracker_size", 100);
-      metrics.emit("memory.seen_tracker_size", 150);
-      metrics.emit("memory.seen_tracker_size", 125);
-
-      const snapshot = metrics.getSnapshot();
-      expect(snapshot.memory.seenTrackerSize).toBe(125); // Last value, not sum
-    });
-
-    it("reset clears all counters", () => {
-      const metrics = createPlainMetrics();
-
-      metrics.emit("event.received");
-      metrics.emit("event.processed");
-      metrics.emit("relay.connect", 1, { relay: TEST_RELAY_URL_PRIMARY });
-
-      metrics.reset();
-
-      const snapshot = metrics.getSnapshot();
-      expect(snapshot.eventsReceived).toBe(0);
-      expect(snapshot.eventsProcessed).toBe(0);
-      expect(Object.keys(snapshot.relays)).toHaveLength(0);
-    });
-  });
-
-  describe("createNoopMetrics", () => {
-    it("ignores emitted metrics", () => {
-      const metrics = createNoopMetrics();
-
-      expect(metrics.emit("event.received")).toBeUndefined();
-      expect(metrics.emit("relay.connect", 1, { relay: TEST_RELAY_URL_PRIMARY })).toBeUndefined();
-    });
-
-    it("returns empty snapshot", () => {
-      const metrics = createNoopMetrics();
-
-      const snapshot = metrics.getSnapshot();
-      expect(snapshot.eventsReceived).toBe(0);
-      expect(snapshot.eventsProcessed).toBe(0);
-    });
-  });
-});
-
-// ============================================================================
-// Circuit Breaker Behavior Tests
-// ============================================================================
-
-describe("Circuit Breaker Behavior", () => {
-  // Test the circuit breaker logic through metrics emissions
-  it("emits circuit breaker metrics in correct sequence", () => {
-    const { events, metrics } = createCollectingMetrics();
-
-    // Simulate 5 failures -> open
-    for (let i = 0; i < 5; i++) {
-      metrics.emit("relay.error", 1, { relay: TEST_RELAY_URL_PRIMARY });
-    }
-    metrics.emit("relay.circuit_breaker.open", 1, { relay: TEST_RELAY_URL_PRIMARY });
-
-    // Simulate recovery
-    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);
-    expect(cbEvents[0].name).toBe("relay.circuit_breaker.open");
-    expect(cbEvents[1].name).toBe("relay.circuit_breaker.half_open");
-    expect(cbEvents[2].name).toBe("relay.circuit_breaker.close");
-  });
-});
-
-// ============================================================================
-// Health Scoring Behavior Tests
-// ============================================================================
-
-describe("Health Scoring", () => {
-  it("metrics track relay errors for health scoring", () => {
-    const metrics = createPlainMetrics();
-
-    // Simulate mixed success/failure pattern
-    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: 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[TEST_RELAY_URL_GOOD].errors).toBe(0);
-    expect(snapshot.relays[TEST_RELAY_URL_BAD].errors).toBe(3);
-  });
-});
-
-// ============================================================================
-// Reconnect Backoff Tests
-// ============================================================================
-
-describe("Reconnect Backoff", () => {
-  it("computes delays within expected bounds", () => {
-    // Compute expected delays (1s, 2s, 4s, 8s, 16s, 32s, 60s cap)
-    const BASE = 1000;
-    const MAX = 60000;
-    const JITTER = 0.3;
-
-    for (let attempt = 0; attempt < 10; attempt++) {
-      const exponential = BASE * 2 ** attempt;
-      const capped = Math.min(exponential, MAX);
-      const minDelay = capped * (1 - JITTER);
-      const maxDelay = capped * (1 + JITTER);
-
-      // These are the expected bounds
-      expect(minDelay).toBeGreaterThanOrEqual(BASE * 0.7);
-      expect(maxDelay).toBeLessThanOrEqual(MAX * 1.3);
-    }
-  });
-});

package/src/nostr-bus.test.ts

@@ -1,231 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  validatePrivateKey,
-  getPublicKeyFromPrivate,
-  isValidPubkey,
-  normalizePubkey,
-  pubkeyToNpub,
-} from "./nostr-key-utils.js";
-import { TEST_HEX_PRIVATE_KEY, TEST_NSEC } from "./test-fixtures.js";
-
-const UPPERCASE_HEX = "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF";
-const INVALID_HEX = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdeg";
-
-function expectThrowsError(run: () => unknown): void {
-  let error: unknown;
-  try {
-    run();
-  } catch (caught) {
-    error = caught;
-  }
-  expect(error).toBeInstanceOf(Error);
-}
-
-const uppercaseHexAcceptanceCases = [
-  {
-    name: "validatePrivateKey",
-    assert: () => {
-      const result = validatePrivateKey(TEST_HEX_PRIVATE_KEY.toUpperCase());
-      expect(result).toBeInstanceOf(Uint8Array);
-    },
-  },
-  {
-    name: "isValidPubkey",
-    assert: () => {
-      expect(isValidPubkey(UPPERCASE_HEX)).toBe(true);
-    },
-  },
-];
-
-const invalidHexRejectionCases = [
-  {
-    name: "validatePrivateKey",
-    assert: (input: string) => {
-      expect(() => validatePrivateKey(input)).toThrow("Private key must be 64 hex characters");
-    },
-  },
-  {
-    name: "isValidPubkey",
-    assert: (input: string) => {
-      expect(isValidPubkey(input)).toBe(false);
-    },
-  },
-];
-
-const whitespaceNormalizationCases = [
-  {
-    name: "validatePrivateKey",
-    assert: () => {
-      const result = validatePrivateKey(`  ${TEST_HEX_PRIVATE_KEY}  `);
-      expect(result).toBeInstanceOf(Uint8Array);
-    },
-  },
-  {
-    name: "normalizePubkey",
-    assert: () => {
-      expect(normalizePubkey(`  ${TEST_HEX_PRIVATE_KEY}  `)).toBe(TEST_HEX_PRIVATE_KEY);
-    },
-  },
-];
-
-describe("hex key helper contracts", () => {
-  it.each(uppercaseHexAcceptanceCases)("$name accepts uppercase hex", ({ assert }) => {
-    assert();
-  });
-
-  it.each(invalidHexRejectionCases)("$name rejects non-hex characters", ({ assert }) => {
-    assert(INVALID_HEX);
-  });
-
-  it.each(invalidHexRejectionCases)("$name rejects empty string", ({ assert }) => {
-    assert("");
-  });
-
-  it.each(whitespaceNormalizationCases)("$name trims whitespace", ({ assert }) => {
-    assert();
-  });
-});
-
-describe("validatePrivateKey", () => {
-  describe("validatePrivateKey hex format", () => {
-    it("accepts valid 64-char 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_PRIVATE_KEY.toLowerCase());
-      expect(result).toBeInstanceOf(Uint8Array);
-    });
-
-    it("accepts mixed case hex", () => {
-      const mixed = "0123456789ABCdef0123456789abcDEF0123456789abcdef0123456789ABCDEF";
-      const result = validatePrivateKey(mixed);
-      expect(result).toBeInstanceOf(Uint8Array);
-    });
-
-    it("trims newlines", () => {
-      const result = validatePrivateKey(`${TEST_HEX_PRIVATE_KEY}\n`);
-      expect(result).toBeInstanceOf(Uint8Array);
-    });
-
-    it("rejects 63-char hex (too short)", () => {
-      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_PRIVATE_KEY + "0")).toThrow(
-        "Private key must be 64 hex characters",
-      );
-    });
-
-    it("rejects whitespace-only string", () => {
-      expect(() => validatePrivateKey("   ")).toThrow("Private key must be 64 hex characters");
-    });
-
-    it("rejects key with 0x prefix", () => {
-      expect(() => validatePrivateKey("0x" + TEST_HEX_PRIVATE_KEY)).toThrow(
-        "Private key must be 64 hex characters",
-      );
-    });
-  });
-
-  describe("nsec format", () => {
-    it("rejects invalid nsec (wrong checksum)", () => {
-      const badNsec = "nsec1invalidinvalidinvalidinvalidinvalidinvalidinvalidinvalid";
-      expectThrowsError(() => validatePrivateKey(badNsec));
-    });
-
-    it("rejects npub (wrong type)", () => {
-      const npub = "npub1qypqxpq9qtpqscx7peytzfwtdjmcv0mrz5rjpej8vjppfkqfqy8s5epk55";
-      expectThrowsError(() => validatePrivateKey(npub));
-    });
-  });
-});
-
-describe("isValidPubkey", () => {
-  describe("isValidPubkey hex format", () => {
-    it("accepts valid 64-char hex pubkey", () => {
-      expect(isValidPubkey(TEST_HEX_PRIVATE_KEY)).toBe(true);
-    });
-
-    it("rejects 63-char hex", () => {
-      const shortHex = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcde";
-      expect(isValidPubkey(shortHex)).toBe(false);
-    });
-
-    it("rejects 65-char hex", () => {
-      const longHex = `${TEST_HEX_PRIVATE_KEY}0`;
-      expect(isValidPubkey(longHex)).toBe(false);
-    });
-  });
-
-  describe("npub format", () => {
-    it("rejects invalid npub", () => {
-      expect(isValidPubkey("npub1invalid")).toBe(false);
-    });
-
-    it("rejects nsec (wrong type)", () => {
-      expect(isValidPubkey(TEST_NSEC)).toBe(false);
-    });
-  });
-
-  describe("edge cases", () => {
-    it("handles whitespace-padded input", () => {
-      expect(isValidPubkey(`  ${TEST_HEX_PRIVATE_KEY}  `)).toBe(true);
-    });
-  });
-});
-
-describe("normalizePubkey", () => {
-  describe("normalizePubkey hex format", () => {
-    it("lowercases hex pubkey", () => {
-      const upper = "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF";
-      const result = normalizePubkey(upper);
-      expect(result).toBe(upper.toLowerCase());
-    });
-
-    it("rejects invalid hex", () => {
-      expect(() => normalizePubkey("invalid")).toThrow("Pubkey must be 64 hex characters");
-    });
-  });
-});
-
-describe("getPublicKeyFromPrivate", () => {
-  it("derives public key from hex private 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_PRIVATE_KEY);
-    const pubkey2 = getPublicKeyFromPrivate(TEST_HEX_PRIVATE_KEY);
-    expect(pubkey1).toBe(pubkey2);
-  });
-
-  it("throws for invalid private key", () => {
-    expectThrowsError(() => getPublicKeyFromPrivate("invalid"));
-  });
-});
-
-describe("pubkeyToNpub", () => {
-  it("converts hex pubkey to npub format", () => {
-    const npub = pubkeyToNpub(TEST_HEX_PRIVATE_KEY);
-    expect(npub).toMatch(/^npub1[a-z0-9]+$/);
-  });
-
-  it("produces consistent output", () => {
-    const npub1 = pubkeyToNpub(TEST_HEX_PRIVATE_KEY);
-    const npub2 = pubkeyToNpub(TEST_HEX_PRIVATE_KEY);
-    expect(npub1).toBe(npub2);
-  });
-
-  it("normalizes uppercase hex first", () => {
-    const upper = TEST_HEX_PRIVATE_KEY.toUpperCase();
-    expect(pubkeyToNpub(TEST_HEX_PRIVATE_KEY)).toBe(pubkeyToNpub(upper));
-  });
-});