nostr-mcp-server 2.0.0 → 3.0.0

package/README.md

@@ -1,12 +1,15 @@
 # Nostr MCP Server
 
+[![npm version](https://badge.fury.io/js/nostr-mcp-server.svg)](https://www.npmjs.com/package/nostr-mcp-server)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 A Model Context Protocol (MCP) server that provides Nostr capabilities to LLMs like Claude.
 
 https://github.com/user-attachments/assets/1d2d47d0-c61b-44e2-85be-5985d2a81c64
 
 ## Features
 
-This server implements 18 tools for interacting with the Nostr network:
+This server implements 40 tools for interacting with the Nostr network:
 
 ### Reading & Querying Tools
 1. `getProfile`: Fetches a user's profile information by public key
@@ -15,26 +18,54 @@ This server implements 18 tools for interacting with the Nostr network:
 4. `getReceivedZaps`: Fetches zaps received by a user, including detailed payment information
 5. `getSentZaps`: Fetches zaps sent by a user, including detailed payment information
 6. `getAllZaps`: Fetches both sent and received zaps for a user, clearly labeled with direction and totals
-7. `searchNips`: Search through Nostr Implementation Possibilities (NIPs) with relevance scoring
+7. `queryEvents`: Generic event query tool supporting kinds/authors/ids/tags and timestamps
+8. `getContactList`: Fetches a user's contact list (kind 3) and followed pubkeys
+9. `getFollowing`: Alias of `getContactList`
+10. `getRelayList`: Fetches a user's relay list metadata (NIP-65 kind 10002)
 
 ### Identity & Profile Management Tools
-8. `createKeypair`: Generate new Nostr keypairs in hex and/or npub/nsec format
-9. `createProfile`: Create a new Nostr profile (kind 0 event) with metadata
-10. `updateProfile`: Update an existing Nostr profile with new metadata
-
-### Note Creation & Publishing Tools  
-11. `createNote`: Create unsigned kind 1 note events with specified content and tags
-12. `signNote`: Sign note events with a private key, generating cryptographically valid signatures
-13. `publishNote`: Publish signed notes to specified Nostr relays
-14. `postNote`: All-in-one authenticated note posting using an existing private key (nsec/hex)
+11. `createKeypair`: Generate new Nostr keypairs in hex and/or npub/nsec format
+12. `createProfile`: Create a new Nostr profile (kind 0 event) with metadata
+13. `updateProfile`: Update an existing Nostr profile with new metadata
+
+### Note Creation & Publishing Tools
+14. `createNote`: Create unsigned kind 1 note events with specified content and tags
+15. `signNote`: Sign note events with a private key, generating cryptographically valid signatures
+16. `publishNote`: Publish signed notes to specified Nostr relays
+17. `postNote`: All-in-one authenticated note posting using an existing private key (nsec/hex)
+
+### Generic Event Tools
+18. `createNostrEvent`: Create unsigned Nostr events of any kind (provides low-level building block for NIPs beyond notes/profiles)
+19. `signNostrEvent`: Sign any unsigned Nostr event with a private key
+20. `publishNostrEvent`: Publish any signed Nostr event to relays
+
+### Social Tools
+21. `setRelayList`: Publish your relay list metadata (NIP-65 kind 10002)
+22. `follow`: Follow a pubkey by updating your contact list (kind 3)
+23. `unfollow`: Unfollow a pubkey by updating your contact list (kind 3)
+24. `reactToEvent`: React to an event (kind 7)
+25. `repostEvent`: Repost an event (kind 6)
+26. `deleteEvent`: Delete one or more events (kind 5 deletion request)
+27. `replyToEvent`: Reply to an event with correct NIP-10 thread tags (kind 1)
+
+### Messaging Tools
+28. `encryptNip04`: Encrypt plaintext using NIP-04 (AES-CBC) for direct messages
+29. `decryptNip04`: Decrypt ciphertext using NIP-04 (AES-CBC) for direct messages
+30. `sendDmNip04`: Send a NIP-04 encrypted DM (kind 4)
+31. `getDmConversationNip04`: Fetch and optionally decrypt a NIP-04 DM conversation (kind 4)
+32. `encryptNip44`: Encrypt plaintext using NIP-44 (ChaCha20 + HMAC)
+33. `decryptNip44`: Decrypt ciphertext using NIP-44 (ChaCha20 + HMAC)
+34. `sendDmNip44`: Send a NIP-44 encrypted DM using NIP-17 gift wrap (kind 1059)
+35. `decryptDmNip44`: Decrypt a NIP-17 gift wrapped DM (kind 1059)
+36. `getDmInboxNip44`: Fetch and decrypt your NIP-44 DM inbox (NIP-17 gift wraps, kind 1059)
 
 ### Anonymous Tools
-15. `sendAnonymousZap`: Prepare an anonymous zap to a profile or event, generating a lightning invoice for payment
-16. `postAnonymousNote`: Post an anonymous note using a randomly generated one-time keypair
+37. `sendAnonymousZap`: Prepare an anonymous zap to a profile or event, generating a lightning invoice for payment
+38. `postAnonymousNote`: Post an anonymous note using a randomly generated one-time keypair
 
 ### NIP-19 Entity Tools
-17. `convertNip19`: Convert between different NIP-19 entity formats (hex, npub, nsec, note, nprofile, nevent, naddr)
-18. `analyzeNip19`: Analyze and decode any NIP-19 entity to understand its type and contents
+39. `convertNip19`: Convert between different NIP-19 entity formats (hex, npub, nsec, note, nprofile, nevent, naddr)
+40. `analyzeNip19`: Analyze and decode any NIP-19 entity to understand its type and contents
 
 All tools fully support both hex public keys and npub format, with user-friendly display of Nostr identifiers.
 
@@ -46,7 +77,21 @@ All tools fully support both hex public keys and npub format, with user-friendly
 npm install -g nostr-mcp-server
 ```
 
-### Option 2: Install from source
+### Option 2: Install from source (using Bun - Recommended)
+
+```bash
+# Clone the repository
+git clone https://github.com/austinkelsay/nostr-mcp-server.git
+cd nostr-mcp-server
+
+# Install dependencies
+bun install
+
+# Build the project
+bun run build
+```
+
+### Option 3: Install from source (using npm)
 
 ```bash
 # Clone the repository
@@ -214,9 +259,6 @@ Once configured, you can ask Claude to use the Nostr tools by making requests li
 - "How many zaps has npub1qny3tkh0acurzla8x3zy4nhrjz5zd8ne6dvrjehx9n9hr3lnj08qwuzwc8 received?"
 - "Show me the zaps sent by npub1qny3tkh0acurzla8x3zy4nhrjz5zd8ne6dvrjehx9n9hr3lnj08qwuzwc8"
 - "Show me all zaps (both sent and received) for npub1qny3tkh0acurzla8x3zy4nhrjz5zd8ne6dvrjehx9n9hr3lnj08qwuzwc8"
-- "Search for NIPs about zaps"
-- "What NIPs are related to long-form content?"
-- "Show me NIP-23 with full content"
 
 ### Identity & Profile Management
 - "Generate a new Nostr keypair for me"
@@ -230,6 +272,24 @@ Once configured, you can ask Claude to use the Nostr tools by making requests li
 - "Publish this signed note to wss://relay.damus.io and wss://nos.lol"
 - "Post a note saying 'GM Nostr! ☀️' using my private key nsec1xyz..."
 
+### Generic Event Operations
+- "Query kind 7 reaction events from this pubkey from the last 24 hours"
+- "Create a kind 7 reaction event to this note ID with content '+'"
+- "Sign this generic Nostr event with my private key and publish it"
+
+### Social & Relay Management
+- "Follow this pubkey using my private key nsec1xyz..."
+- "Unfollow this pubkey using my private key"
+- "Reply to this event ID with 'Great point' using my private key"
+- "Set my relay list to wss://relay.damus.io and wss://nos.lol"
+- "Fetch the relay list for this npub"
+
+### Direct Messaging (NIP-04 / NIP-44)
+- "Encrypt 'hey' with NIP-04 for this recipient pubkey"
+- "Send a NIP-04 DM saying 'hello' to this pubkey using my private key"
+- "Send a NIP-44 DM saying 'check this out' to this pubkey"
+- "Fetch and decrypt my NIP-44 inbox using my private key"
+
 ### Anonymous Operations
 - "Send an anonymous zap of 100 sats to npub1qny3tkh0acurzla8x3zy4nhrjz5zd8ne6dvrjehx9n9hr3lnj08qwuzwc8"
 - "Send 1000 sats to note1abcdef... with a comment saying 'Great post!'"
@@ -349,22 +409,17 @@ For zap queries, you can enable extra validation and debugging:
 
 - "Show me all zaps for npub1qny3tkh0acurzla8x3zy4nhrjz5zd8ne6dvrjehx9n9hr3lnj08qwuzwc8 with validation and debug enabled"
 
-For NIP searches, you can control the number of results and include full content:
-
-- "Search for NIPs about zaps with full content"
-- "Show me the top 5 NIPs about relays"
-- "What NIPs are related to encryption? Show me 15 results"
-
 ## Limitations
 
 - The server has a default 8-second timeout for queries to prevent hanging
-- Only public keys in hex format or npub format are supported
+- When a tool expects a public key, both hex and npub formats are supported
 - Only a subset of relays is used by default
 
 ## Implementation Details
 
 - Built with **[snstr](https://github.com/austinkelsay/snstr)** - a lightweight, modern TypeScript library for Nostr protocol implementation
 - Native support for npub format using NIP-19 encoding/decoding
+- Relay authentication support for NIP-42 where relays require AUTH events
 - NIP-57 compliant zap receipt detection with direction-awareness (sent/received/self)
 - Advanced bolt11 invoice parsing with payment amount extraction
 - Smart caching system for improved performance with large volumes of zaps
@@ -417,49 +472,57 @@ To modify or extend this server:
    - `index.ts`: Main server and tool registration
    - `profile/profile-tools.ts`: Identity management, keypair generation, profile creation ([Documentation](./profile/README.md))
    - `note/note-tools.ts`: Note creation, signing, publishing, and reading functionality ([Documentation](./note/README.md))
+   - `event/event-tools.ts`: Generic event querying/creation/signing/publishing
+   - `social/social-tools.ts`: Follow/unfollow/reaction/repost/delete/reply flows
+   - `relay/relay-tools.ts`: Relay list (NIP-65) read/write and NIP-42 auth support
+   - `dm/dm-tools.ts`: NIP-04 and NIP-44/NIP-17 direct message tooling
    - `zap/zap-tools.ts`: Zap-related functionality ([Documentation](./zap/README.md))
-   - `nips/nips-tools.ts`: Functions for searching NIPs ([Documentation](./nips/README.md))
    - `utils/`: Shared utility functions
      - `constants.ts`: Global constants and relay configurations
      - `conversion.ts`: NIP-19 entity conversion utilities (hex/npub/nprofile/nevent/naddr)
      - `formatting.ts`: Output formatting helpers
+     - `keys.ts`: Shared private key normalization and auth key helpers
      - `nip19-tools.ts`: NIP-19 entity conversion and analysis tools
      - `pool.ts`: Nostr connection pool management
      - `ephemeral-relay.ts`: In-memory Nostr relay for testing
 
-2. Run `npm run build` to compile
+2. Run `bun run build` (or `npm run build`) to compile.
 
 3. Restart Claude for Desktop or Cursor to pick up your changes
 
 ## Testing
 
-We've implemented a comprehensive test suite using Jest to test both basic functionality and integration with the Nostr protocol:
+We've implemented a comprehensive test suite using Bun's native test runner to test both basic functionality and integration with the Nostr protocol:
 
 ```bash
-# Run all tests
-npm test
+# Run all tests (using Bun - Recommended)
+bun test
 
 # Run a specific test file
-npm test -- __tests__/basic.test.ts
+bun test __tests__/basic.test.ts
 
 # Run integration tests
-npm test -- __tests__/integration.test.ts
+bun test __tests__/integration.test.ts
 ```
 
 The test suite includes:
 
 ### Unit Tests
 - `basic.test.ts` - Tests simple profile formatting and zap receipt processing
+- `dm-tools.test.ts` - Tests NIP-04/NIP-44 direct message encryption/decryption and message workflows
+- `event-tools.test.ts` - Tests generic event query/create/sign/publish helpers
 - `profile-notes-simple.test.ts` - Tests profile and note data structures
 - `profile-tools.test.ts` - Tests keypair generation, profile creation, and identity management
 - `note-creation.test.ts` - Tests note creation, signing, and publishing workflows
 - `note-tools-functions.test.ts` - Tests note formatting, creation, signing, and publishing functions
 - `note-tools-unit.test.ts` - Unit tests for note formatting functions
 - `profile-postnote.test.ts` - Tests authenticated note posting with existing private keys
+- `relay-tools.test.ts` - Tests relay list tooling (NIP-65) and authenticated relay interactions
+- `social-tools.test.ts` - Tests follow/unfollow, reactions, reposts, deletes, and replies
 - `zap-tools-simple.test.ts` - Tests zap processing and anonymous zap preparation
 - `zap-tools-tests.test.ts` - Tests zap validation, parsing, and direction determination
-- `search-nips-simple.test.ts` - Tests NIPs search functionality with relevance scoring
 - `nip19-conversion.test.ts` - Tests NIP-19 entity conversion and analysis (28 test cases)
+- `nip42-auth.test.ts` - Tests NIP-42 relay authentication flow and key handling
 
 ### Integration Tests
 - `integration.test.ts` - Tests interaction with an ephemeral Nostr relay including:
@@ -491,8 +554,11 @@ The codebase is organized into modules:
 - Specialized functionality in dedicated directories:
   - [`profile/`](./profile/README.md): Identity management, keypair generation, and profile creation
   - [`note/`](./note/README.md): Note creation, signing, publishing, and reading functionality
+  - `event/`: Generic event query/create/sign/publish functionality
+  - `social/`: Social interactions (follow/unfollow/reactions/reposts/deletes/replies)
+  - `relay/`: Relay list tooling and relay auth support
+  - `dm/`: NIP-04 and NIP-44/NIP-17 direct messaging tools
   - [`zap/`](./zap/README.md): Zap handling and anonymous zapping
-  - [`nips/`](./nips/README.md): NIPs search and caching functionality
 - Common utilities in the `utils/` directory
 
 This modular structure makes the codebase more maintainable, reduces duplication, and enables easier feature extensions. For detailed information about each module's features and implementation, see their respective documentation.

package/build/__tests__/basic.test.js

@@ -1,6 +1,6 @@
-import { jest } from '@jest/globals';
+import { describe, test, expect, mock } from 'bun:test';
 // Mock the formatProfile function
-const mockFormatProfile = jest.fn((profile) => {
+const mockFormatProfile = mock((profile) => {
     const content = typeof profile.content === 'string'
         ? JSON.parse(profile.content)
         : profile.content;

package/build/__tests__/dm-tools.test.js

@@ -0,0 +1,192 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { schnorr } from "@noble/curves/secp256k1";
+import { NostrRelay } from "../utils/ephemeral-relay.js";
+import { QUERY_TIMEOUT } from "../utils/constants.js";
+import { encryptNip04, decryptNip04, sendDmNip04, getDmConversationNip04, encryptNip44, decryptNip44, sendDmNip44, getDmInboxNip44, } from "../dm/dm-tools.js";
+describe("dm-tools", () => {
+    let relay;
+    let relayUrl;
+    let authRelay;
+    let authRelayUrl;
+    // Fixed test keys (32 bytes hex). Not used outside this test context.
+    const alicePriv = "0000000000000000000000000000000000000000000000000000000000000001";
+    const bobPriv = "0000000000000000000000000000000000000000000000000000000000000002";
+    const alicePub = Buffer.from(schnorr.getPublicKey(alicePriv)).toString("hex");
+    const bobPub = Buffer.from(schnorr.getPublicKey(bobPriv)).toString("hex");
+    beforeAll(async () => {
+        relay = new NostrRelay(0);
+        await relay.start();
+        relayUrl = relay.url;
+        authRelay = new NostrRelay(0, undefined, true);
+        await authRelay.start();
+        authRelayUrl = authRelay.url;
+    });
+    afterAll(async () => {
+        await relay.close();
+        await authRelay.close();
+    });
+    test("NIP-04 encrypt/decrypt roundtrip", async () => {
+        const msg = `hello-${Date.now()}`;
+        const enc = await encryptNip04({ privateKey: alicePriv, recipientPubkey: bobPub, plaintext: msg });
+        expect(enc.success).toBe(true);
+        expect(enc.ciphertext).toBeTruthy();
+        const dec = await decryptNip04({ privateKey: bobPriv, senderPubkey: alicePub, ciphertext: enc.ciphertext });
+        expect(dec.success).toBe(true);
+        expect(dec.plaintext).toBe(msg);
+    });
+    test("NIP-44 encrypt/decrypt roundtrip", async () => {
+        const msg = `hello44-${Date.now()}`;
+        const enc = await encryptNip44({ privateKey: alicePriv, recipientPubkey: bobPub, plaintext: msg });
+        expect(enc.success).toBe(true);
+        expect(enc.ciphertext).toBeTruthy();
+        const dec = await decryptNip44({ privateKey: bobPriv, senderPubkey: alicePub, ciphertext: enc.ciphertext });
+        expect(dec.success).toBe(true);
+        expect(dec.plaintext).toBe(msg);
+    });
+    test("sendDmNip04 + getDmConversationNip04 decrypts both directions", async () => {
+        const a1 = await sendDmNip04({
+            privateKey: alicePriv,
+            recipientPubkey: bobPub,
+            content: "a->b",
+            relays: [relayUrl],
+        });
+        expect(a1.success).toBe(true);
+        const b1 = await sendDmNip04({
+            privateKey: bobPriv,
+            recipientPubkey: alicePub,
+            content: "b->a",
+            relays: [relayUrl],
+        });
+        expect(b1.success).toBe(true);
+        // Poll until both are queryable (relay OK may arrive before store).
+        const deadline = Date.now() + QUERY_TIMEOUT;
+        let convo = null;
+        while (Date.now() < deadline) {
+            convo = await getDmConversationNip04({
+                privateKey: alicePriv,
+                peerPubkey: bobPub,
+                relays: [relayUrl],
+                limit: 10,
+                decrypt: true,
+            });
+            if (convo.success && (convo.messages ?? []).length >= 2)
+                break;
+            await new Promise((r) => setTimeout(r, 25));
+        }
+        expect(convo?.success).toBe(true);
+        const contents = (convo.messages ?? []).map((m) => m.content);
+        expect(contents).toContain("a->b");
+        expect(contents).toContain("b->a");
+    });
+    test("sendDmNip44 + getDmInboxNip44 decrypts gift wrapped message", async () => {
+        const msg = `gift-${Date.now()}`;
+        const sent = await sendDmNip44({ privateKey: alicePriv, recipientPubkey: bobPub, content: msg, relays: [relayUrl] });
+        expect(sent.success).toBe(true);
+        const deadline = Date.now() + QUERY_TIMEOUT;
+        let inbox = null;
+        while (Date.now() < deadline) {
+            inbox = await getDmInboxNip44({ privateKey: bobPriv, relays: [relayUrl], limit: 25 });
+            if (inbox.success && (inbox.messages ?? []).some((m) => m.content === msg))
+                break;
+            await new Promise((r) => setTimeout(r, 25));
+        }
+        expect(inbox?.success).toBe(true);
+        const found = (inbox.messages ?? []).find((m) => m.content === msg);
+        expect(found).toBeTruthy();
+        expect(found.from).toBe(alicePub);
+    });
+    test("DM tools pass authPrivateKey through for NIP-42 relays", async () => {
+        const nip04Msg = `auth-nip04-${Date.now()}`;
+        const noAuth04 = await sendDmNip04({
+            privateKey: alicePriv,
+            recipientPubkey: bobPub,
+            content: nip04Msg,
+            relays: [authRelayUrl],
+        });
+        expect(noAuth04.success).toBe(false);
+        const withAuth04 = await sendDmNip04({
+            privateKey: alicePriv,
+            recipientPubkey: bobPub,
+            content: nip04Msg,
+            relays: [authRelayUrl],
+            authPrivateKey: alicePriv,
+        });
+        expect(withAuth04.success).toBe(true);
+        const noAuth04Query = await getDmConversationNip04({
+            privateKey: bobPriv,
+            peerPubkey: alicePub,
+            relays: [authRelayUrl],
+            limit: 10,
+        });
+        expect(noAuth04Query.success).toBe(false);
+        const deadline04 = Date.now() + QUERY_TIMEOUT;
+        let convo04 = null;
+        while (Date.now() < deadline04) {
+            convo04 = await getDmConversationNip04({
+                privateKey: bobPriv,
+                peerPubkey: alicePub,
+                relays: [authRelayUrl],
+                authPrivateKey: bobPriv,
+                limit: 10,
+                decrypt: true,
+            });
+            if (convo04.success && (convo04.messages ?? []).some((m) => m.content === nip04Msg))
+                break;
+            await new Promise((r) => setTimeout(r, 25));
+        }
+        expect(convo04?.success).toBe(true);
+        expect((convo04.messages ?? []).some((m) => m.content === nip04Msg)).toBe(true);
+        const nip44Msg = `auth-nip44-${Date.now()}`;
+        const noAuth44 = await sendDmNip44({
+            privateKey: alicePriv,
+            recipientPubkey: bobPub,
+            content: nip44Msg,
+            relays: [authRelayUrl],
+        });
+        expect(noAuth44.success).toBe(false);
+        const withAuth44 = await sendDmNip44({
+            privateKey: alicePriv,
+            recipientPubkey: bobPub,
+            content: nip44Msg,
+            relays: [authRelayUrl],
+            authPrivateKey: alicePriv,
+        });
+        expect(withAuth44.success).toBe(true);
+        const noAuth44Query = await getDmInboxNip44({
+            privateKey: bobPriv,
+            relays: [authRelayUrl],
+            limit: 25,
+        });
+        expect(noAuth44Query.success).toBe(false);
+        const deadline44 = Date.now() + QUERY_TIMEOUT;
+        let inbox44 = null;
+        while (Date.now() < deadline44) {
+            inbox44 = await getDmInboxNip44({
+                privateKey: bobPriv,
+                relays: [authRelayUrl],
+                authPrivateKey: bobPriv,
+                limit: 25,
+            });
+            if (inbox44.success && (inbox44.messages ?? []).some((m) => m.content === nip44Msg))
+                break;
+            await new Promise((r) => setTimeout(r, 25));
+        }
+        expect(inbox44?.success).toBe(true);
+        expect((inbox44.messages ?? []).some((m) => m.content === nip44Msg)).toBe(true);
+    });
+    test("DM conversation/inbox return structured error for invalid private keys", async () => {
+        const convo = await getDmConversationNip04({
+            privateKey: "bad-key",
+            peerPubkey: bobPub,
+            relays: [relayUrl],
+        });
+        expect(convo.success).toBe(false);
+        expect(convo.message).toBe("Invalid private key format.");
+        const inbox = await getDmInboxNip44({
+            privateKey: "bad-key",
+            relays: [relayUrl],
+        });
+        expect(inbox.success).toBe(false);
+        expect(inbox.message).toBe("Invalid private key format.");
+    });
+});

package/build/__tests__/event-tools.test.js

@@ -0,0 +1,64 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { NostrRelay } from "../utils/ephemeral-relay.js";
+import { DEFAULT_RELAYS, KINDS, QUERY_TIMEOUT } from "../utils/constants.js";
+import { createNostrEvent, signNostrEvent, publishNostrEvent, queryEvents, } from "../event/event-tools.js";
+describe("event-tools", () => {
+    let relay;
+    let relayUrl;
+    beforeAll(async () => {
+        relay = new NostrRelay(0);
+        await relay.start();
+        relayUrl = relay.url;
+    });
+    afterAll(async () => {
+        await relay.close();
+    });
+    test("create/sign/publish/query a generic kind 7 reaction event", async () => {
+        // Fixed test key (32 bytes hex). Not used outside this test context.
+        const privateKey = "0000000000000000000000000000000000000000000000000000000000000001";
+        const created = await createNostrEvent({
+            kind: KINDS.REACTION,
+            content: "+",
+            tags: [["e", "deadbeef".repeat(8)]],
+            privateKey,
+        });
+        expect(created.success).toBe(true);
+        expect(created.event?.kind).toBe(KINDS.REACTION);
+        expect(created.event?.content).toBe("+");
+        const signed = await signNostrEvent({
+            privateKey,
+            event: created.event,
+        });
+        expect(signed.success).toBe(true);
+        expect(signed.signedEvent?.id).toBeTruthy();
+        expect(signed.signedEvent?.sig).toBeTruthy();
+        // Prefer the ephemeral relay for test determinism; fall back to defaults if it's unavailable.
+        const relays = relayUrl ? [relayUrl] : DEFAULT_RELAYS;
+        const published = await publishNostrEvent({
+            signedEvent: signed.signedEvent,
+            relays,
+        });
+        if (!published.success) {
+            throw new Error(published.message);
+        }
+        expect(published.success).toBe(true);
+        // Poll queryEvents until it shows up (relay sends OK before storing).
+        const deadline = Date.now() + QUERY_TIMEOUT;
+        let last = null;
+        while (Date.now() < deadline) {
+            last = await queryEvents({
+                relays,
+                kinds: [KINDS.REACTION],
+                authors: [signed.signedEvent.pubkey],
+                limit: 25,
+            });
+            if (last.success && (last.events ?? []).some((e) => e.id === signed.signedEvent.id))
+                break;
+            await new Promise((r) => setTimeout(r, 25));
+        }
+        if (!last?.success) {
+            throw new Error(last?.message || "queryEvents failed");
+        }
+        expect((last.events ?? []).some((e) => e.id === signed.signedEvent.id)).toBe(true);
+    });
+});

package/build/__tests__/integration.test.js

@@ -1,6 +1,7 @@
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
 import { NostrRelay } from '../utils/ephemeral-relay.js';
 import { schnorr } from '@noble/curves/secp256k1';
-import { randomBytes } from 'crypto';
+import { randomBytes } from 'node:crypto';
 import { sha256 } from '@noble/hashes/sha256';
 // Generate a keypair for testing
 function generatePrivateKey() {
@@ -34,14 +35,14 @@ function createSignedEvent(privateKey, kind, content, tags = []) {
 }
 describe('Nostr Integration Tests', () => {
     let relay;
-    const testPort = 9700;
     let privateKey;
     let publicKey;
     beforeAll(async () => {
         privateKey = generatePrivateKey();
         publicKey = getPublicKey(privateKey);
         // Start the ephemeral relay
-        relay = new NostrRelay(testPort);
+        // Use port 0 to avoid CI/local port conflicts.
+        relay = new NostrRelay(0);
         await relay.start();
     });
     afterAll(async () => {

package/build/__tests__/mocks.js

@@ -1,5 +1,3 @@
-// Mock Nostr events and utility functions for testing
-import { jest } from '@jest/globals';
 export const MOCK_HEX_PUBKEY = '7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e';
 export const MOCK_NPUB = 'npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6';
 export const mockProfile = {
@@ -64,14 +62,6 @@ export const mockZapReceipt = {
     content: '',
     sig: 'mock_signature'
 };
-// Mock pool functions
-export const mockPool = {
-    get: jest.fn(),
-    querySync: jest.fn(),
-    close: jest.fn()
-};
-// Mock for getFreshPool function
-export const getFreshPoolMock = jest.fn().mockReturnValue(mockPool);
 // Mock response for lightning service for anonymous zaps
 export const mockLightningServiceResponse = {
     callback: 'https://example.com/callback',

package/build/__tests__/nip19-conversion.test.js

@@ -1,3 +1,4 @@
+import { describe, it, expect, beforeAll } from 'bun:test';
 import { convertNip19, analyzeNip19 } from '../utils/nip19-tools.js';
 import { generateKeypair, encodePublicKey, encodePrivateKey, encodeNoteId, encodeProfile, encodeEvent, encodeAddress } from 'snstr';
 describe('NIP-19 Conversion Tools', () => {

package/build/__tests__/nip42-auth.test.js

@@ -0,0 +1,53 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { NostrRelay } from "../utils/ephemeral-relay.js";
+import { createNostrEvent, signNostrEvent, publishNostrEvent, queryEvents } from "../event/event-tools.js";
+import { KINDS } from "../utils/constants.js";
+describe("NIP-42 AUTH", () => {
+    let relay;
+    let relayUrl;
+    // Fixed test key (32 bytes hex). Not used outside this test context.
+    const privateKey = "0000000000000000000000000000000000000000000000000000000000000001";
+    beforeAll(async () => {
+        relay = new NostrRelay(0, undefined, true);
+        await relay.start();
+        relayUrl = relay.url;
+    });
+    afterAll(async () => {
+        await relay.close();
+    });
+    test("publish/query fail without authPrivateKey and succeed with it", async () => {
+        const created = await createNostrEvent({
+            kind: KINDS.TEXT,
+            content: `auth-${Date.now()}`,
+            tags: [],
+            privateKey,
+        });
+        expect(created.success).toBe(true);
+        const signed = await signNostrEvent({ privateKey, event: created.event });
+        expect(signed.success).toBe(true);
+        const noAuthPub = await publishNostrEvent({ signedEvent: signed.signedEvent, relays: [relayUrl] });
+        expect(noAuthPub.success).toBe(false);
+        const withAuthPub = await publishNostrEvent({
+            signedEvent: signed.signedEvent,
+            relays: [relayUrl],
+            authPrivateKey: privateKey,
+        });
+        expect(withAuthPub.success).toBe(true);
+        const noAuthQuery = await queryEvents({
+            relays: [relayUrl],
+            kinds: [KINDS.TEXT],
+            authors: [signed.signedEvent.pubkey],
+            limit: 10,
+        });
+        expect(noAuthQuery.success).toBe(false);
+        const withAuthQuery = await queryEvents({
+            relays: [relayUrl],
+            authPrivateKey: privateKey,
+            kinds: [KINDS.TEXT],
+            authors: [signed.signedEvent.pubkey],
+            limit: 10,
+        });
+        expect(withAuthQuery.success).toBe(true);
+        expect((withAuthQuery.events ?? []).some((e) => e.id === signed.signedEvent.id)).toBe(true);
+    });
+});

package/build/__tests__/note-creation.test.js

@@ -1,3 +1,4 @@
+import { describe, it, expect } from 'bun:test';
 import { createNote, signNote, publishNote } from '../note/note-tools.js';
 import { createKeypair } from '../profile/profile-tools.js';
 describe('Note Creation Tools', () => {

package/build/__tests__/note-tools-functions.test.js

@@ -1,16 +1,16 @@
-import { jest } from '@jest/globals';
+import { mock, describe, it, expect, beforeAll, beforeEach } from 'bun:test';
 import { generateKeypair } from 'snstr';
 // Mock the pool to prevent real WebSocket connections
 const mockPool = {
-    close: jest.fn(),
-    publish: jest.fn().mockReturnValue([
+    close: mock(() => { }),
+    publish: mock(() => [
         Promise.resolve({ success: true }),
         Promise.resolve({ success: true })
     ])
 };
 // Mock the pool module directly
-jest.mock('../utils/pool.js', () => ({
-    getFreshPool: jest.fn(() => mockPool)
+mock.module('../utils/pool.js', () => ({
+    getFreshPool: mock(() => mockPool)
 }));
 // Now import the functions that use the mocked module
 import { formatProfile, formatNote, createNote, signNote, publishNote } from '../note/note-tools.js';
@@ -19,6 +19,11 @@ describe('Note Tools Functions', () => {
     beforeAll(async () => {
         testKeys = await generateKeypair();
     });
+    beforeEach(() => {
+        // Reset mock state between tests
+        mockPool.close.mockClear();
+        mockPool.publish.mockClear();
+    });
     describe('formatProfile', () => {
         it('should format a complete profile', () => {
             const profileEvent = {

package/build/__tests__/note-tools-unit.test.js

@@ -1,3 +1,4 @@
+import { describe, it, expect, beforeAll } from 'bun:test';
 import { generateKeypair } from 'snstr';
 import { formatProfile, formatNote, } from '../note/note-tools.js';
 describe('Note Tools Unit Tests', () => {