nostr-mcp-server 2.1.0 → 3.0.0

package/README.md

@@ -9,7 +9,7 @@ https://github.com/user-attachments/assets/1d2d47d0-c61b-44e2-85be-5985d2a81c64
 
 ## Features
 
-This server implements 17 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
@@ -18,25 +18,54 @@ This server implements 17 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. `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
-7. `createKeypair`: Generate new Nostr keypairs in hex and/or npub/nsec format
-8. `createProfile`: Create a new Nostr profile (kind 0 event) with metadata
-9. `updateProfile`: Update an existing Nostr profile with new metadata
+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
-10. `createNote`: Create unsigned kind 1 note events with specified content and tags
-11. `signNote`: Sign note events with a private key, generating cryptographically valid signatures
-12. `publishNote`: Publish signed notes to specified Nostr relays
-13. `postNote`: All-in-one authenticated note posting using an existing private key (nsec/hex)
+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
-14. `sendAnonymousZap`: Prepare an anonymous zap to a profile or event, generating a lightning invoice for payment
-15. `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
-16. `convertNip19`: Convert between different NIP-19 entity formats (hex, npub, nsec, note, nprofile, nevent, naddr)
-17. `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.
 
@@ -243,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!'"
@@ -365,13 +412,14 @@ For zap queries, you can enable extra validation and debugging:
 ## 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
@@ -424,16 +472,21 @@ 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))
    - `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 `bun run build` (or `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
 
@@ -456,15 +509,20 @@ 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
 - `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:
@@ -496,6 +554,10 @@ 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
 - Common utilities in the `utils/` directory
 

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__/error-handling.test.js

@@ -0,0 +1,145 @@
+import { describe, expect, test, jest, beforeEach } from '@jest/globals';
+// Mock the actual Nostr pool functionality
+jest.mock('../utils/pool.js', () => {
+    return {
+        getRelayPool: jest.fn(() => ({
+            connect: jest.fn(),
+            close: jest.fn(),
+            subscribeMany: jest.fn(),
+        })),
+    };
+});
+// Mock setTimeout for testing timeouts
+jest.useFakeTimers();
+// Helper function for creating timed out promises
+const createTimedOutPromise = () => new Promise((resolve, reject) => {
+    setTimeout(() => reject(new Error('Request timed out')), 10000);
+});
+// Mock getProfile that simulates various error scenarios
+const mockGetProfile = jest.fn();
+// Helpers for common error scenarios
+const simulateTimeoutError = () => {
+    mockGetProfile.mockImplementationOnce(() => createTimedOutPromise());
+};
+const simulateNetworkError = () => {
+    mockGetProfile.mockImplementationOnce(() => Promise.reject(new Error('Failed to connect to relay')));
+};
+const simulateInvalidPubkey = () => {
+    mockGetProfile.mockImplementationOnce(() => Promise.reject(new Error('Invalid pubkey format')));
+};
+const simulateMalformedEvent = () => {
+    mockGetProfile.mockImplementationOnce(() => Promise.resolve({
+        error: 'Malformed event',
+        details: 'Event missing required signature'
+    }));
+};
+describe('Error Handling and Edge Cases', () => {
+    beforeEach(() => {
+        mockGetProfile.mockReset();
+    });
+    test('timeout handling', async () => {
+        simulateTimeoutError();
+        try {
+            jest.useFakeTimers();
+            const profilePromise = mockGetProfile('valid-pubkey');
+            // Fast-forward time to trigger timeout
+            jest.advanceTimersByTime(10000);
+            await profilePromise;
+            fail('Expected promise to reject with timeout error');
+        }
+        catch (error) {
+            expect(error.message).toContain('timed out');
+        }
+    });
+    test('invalid pubkey format handling', async () => {
+        simulateInvalidPubkey();
+        try {
+            await mockGetProfile('invalid-pubkey-format');
+            fail('Expected promise to reject with invalid pubkey error');
+        }
+        catch (error) {
+            expect(error.message).toContain('Invalid pubkey');
+        }
+    });
+    test('network error handling', async () => {
+        simulateNetworkError();
+        try {
+            await mockGetProfile('valid-pubkey');
+            fail('Expected promise to reject with network error');
+        }
+        catch (error) {
+            expect(error.message).toContain('Failed to connect');
+        }
+    });
+    test('malformed event handling', async () => {
+        simulateMalformedEvent();
+        const result = await mockGetProfile('valid-pubkey');
+        expect(result.error).toBeDefined();
+        expect(result.error).toContain('Malformed event');
+    });
+    test('empty pubkey handling', async () => {
+        // Empty string pubkey
+        simulateInvalidPubkey();
+        try {
+            await mockGetProfile('');
+            fail('Expected promise to reject with invalid pubkey error');
+        }
+        catch (error) {
+            expect(error.message).toContain('Invalid pubkey');
+        }
+    });
+    test('extremely long pubkey handling', async () => {
+        // Extremely long input should be rejected
+        simulateInvalidPubkey();
+        const veryLongPubkey = 'a'.repeat(1000);
+        try {
+            await mockGetProfile(veryLongPubkey);
+            fail('Expected promise to reject with invalid pubkey error');
+        }
+        catch (error) {
+            expect(error.message).toContain('Invalid pubkey');
+        }
+    });
+    test('special character handling in pubkey', async () => {
+        // Pubkey with special characters
+        simulateInvalidPubkey();
+        try {
+            await mockGetProfile('npub1<script>alert("xss")</script>');
+            fail('Expected promise to reject with invalid pubkey error');
+        }
+        catch (error) {
+            expect(error.message).toContain('Invalid pubkey');
+        }
+    });
+    test('null or undefined pubkey handling', async () => {
+        // Null pubkey
+        simulateInvalidPubkey();
+        try {
+            await mockGetProfile(null);
+            fail('Expected promise to reject with invalid pubkey error');
+        }
+        catch (error) {
+            expect(error.message).toContain('Invalid pubkey');
+        }
+        // Undefined pubkey
+        simulateInvalidPubkey();
+        try {
+            await mockGetProfile(undefined);
+            fail('Expected promise to reject with invalid pubkey error');
+        }
+        catch (error) {
+            expect(error.message).toContain('Invalid pubkey');
+        }
+    });
+    test('all relays failing scenario', async () => {
+        // Simulate all relays failing
+        simulateNetworkError();
+        try {
+            await mockGetProfile('valid-pubkey', { relays: ['wss://relay1.example.com', 'wss://relay2.example.com'] });
+            fail('Expected promise to reject when all relays fail');
+        }
+        catch (error) {
+            expect(error.message).toContain('Failed to connect');
+        }
+    });
+});

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);
+    });
+});