ncc-05 1.1.5 → 1.1.8

package/README.md

@@ -1,120 +1,267 @@
 # ncc-05
 
-**Nostr Community Convention 05 - Identity-Bound Service Locator Resolution.**
-
-A TypeScript library for publishing and resolving dynamic, encrypted service endpoints (IP, Port, Onion) bound to cryptographic identities using Nostr `kind:30058` events.
-
-## Features
-
-- **Identity-Centric**: Endpoints are bound to a Nostr Pubkey.
-- **Privacy-First**: NIP-44 encryption is mandatory by default.
-- **Multi-Recipient Support**: Implement "Wrapping" patterns to share endpoints with groups without sharing private keys.
-- **NIP-65 Gossip**: Built-in support for discovering a publisher's preferred relays.
-- **Tor Ready**: Easy integration with SOCKS5 proxies for anonymous resolution.
-- **Type Safe**: Fully typed with TypeScript.
+Nostr Community Convention 05 - Identity-Bound Service Locator Resolution
 
 ## Installation
 
+You can install this library using npm:
+
 ```bash
 npm install ncc-05
 ```
 
-## Usage
+## Configuration
 
-### 1. Basic Resolution (Self or Public)
+### Relays
 
-Resolve an identity-bound service locator for a given pubkey.
+The `NCC05Resolver` uses a set of bootstrap relays to discover service locators. By default, it uses `['wss://relay.damus.io', 'wss://nos.lol']`. You can provide your own list of relays during initialization:
 
 ```typescript
 import { NCC05Resolver } from 'ncc-05';
-import { nip19 } from 'nostr-tools';
 
-const resolver = new NCC05Resolver();
+const customRelays = ['wss://relay.example.com', 'wss://another.relay.io'];
+const resolver = new NCC05Resolver({ bootstrapRelays: customRelays });
+```
 
-// Resolve using an npub (or hex pubkey)
-const target = 'npub1...';
-const mySecretKey = ...; // Uint8Array needed for encrypted records
+The `NCC05Publisher` requires you to specify the relays to which you want to publish events for each `publish` or `publishWrapped` call:
 
-const payload = await resolver.resolve(target, mySecretKey, 'addr', { 
-    gossip: true, // Follow NIP-65 hints
-    strict: true  // Reject expired records
-});
+```typescript
+import { NCC05Publisher } from 'ncc-05';
 
-if (payload) {
-    console.log('Resolved Endpoints:', payload.endpoints);
-}
+const publisher = new NCC05Publisher();
+const relaysToPublishTo = ['wss://relay.example.com'];
+// ... then call publisher.publish(relaysToPublishTo, ...)
 ```
 
-### 2. Targeted Encryption (Friend-to-Friend)
+### Shared SimplePool
 
-Alice publishes a record that only Bob can decrypt.
+Both `NCC05Resolver` and `NCC05Publisher` can optionally share a `nostr-tools` `SimplePool` instance. This is useful for managing relay connections more efficiently across your application.
 
 ```typescript
-import { NCC05Publisher } from 'ncc-05';
+import { SimplePool } from 'nostr-tools';
+import { NCC05Resolver, NCC05Publisher } from 'ncc-05';
 
-const publisher = new NCC05Publisher();
-const AliceSK = ...;
-const BobPK = "..."; // Bob's hex pubkey
+const pool = new SimplePool();
 
-await publisher.publish(relays, AliceSK, payload, {
-    identifier: 'for-bob',
-    recipientPubkey: BobPK // Encrypts specifically for Bob
-});
+const resolver = new NCC05Resolver({ pool });
+const publisher = new NCC05Publisher({ pool });
+
+// Remember to close the pool when done if you created it externally
+// pool.close(); 
 ```
 
-### 3. Group Wrapping (One Event, Many Recipients)
+## Usage
+
+This library is designed for both resolving and publishing identity-bound service locators.
+
+### 1. Resolving a Service Locator
 
-Alice shares her endpoint with a list of authorized friends in a single event.
+You can resolve a service locator for a user's identity using the `NCC05Resolver`. This involves specifying the target user's public key, your (optional) secret key for decryption, and a service identifier.
 
 ```typescript
-await publisher.publishWrapped(
-    relays, 
-    AliceSK, 
-    [BobPK, CharliePK, DavePK], 
-    payload, 
-    'private-group'
-);
-
-// Bob resolves it using his own key:
-const payload = await resolver.resolve(AlicePK, BobSK, 'private-group');
+import { NCC05Resolver, NCC05Payload, NCC05TimeoutError } from 'ncc-05';
+import { SimplePool } from 'nostr-tools';
+
+// Optional: Share an existing connection pool to manage relay connections
+const pool = new SimplePool(); 
+const resolver = new NCC05Resolver({ 
+    pool,
+    timeout: 10000 // Custom timeout in milliseconds (default is 10000)
+});
+
+// The target user's public key (can be 'npub1...' (bech32 encoded) or a hex string)
+const targetPubkey = 'npub1w9...'; 
+
+// Your secret key (hex string or Uint8Array) is required if the record is encrypted for you.
+// If the record is public or encrypted for the targetPubkey itself, your secretKey is not strictly needed.
+const mySecretKey = "your_hex_secret_key"; 
+
+// The 'd' tag identifier for the service (default is 'addr')
+const serviceIdentifier = 'chat.example.com'; 
+
+try {
+    const payload: NCC05Payload | null = await resolver.resolve(targetPubkey, mySecretKey, serviceIdentifier, { 
+        gossip: true,   // Attempt NIP-65 relay discovery
+        strict: false   // If true, expired records return null; otherwise, a warning is logged.
+    });
+
+    if (payload) {
+        console.log('Resolved Service Locator Payload:', payload);
+        // Example output structure:
+        // {
+        //   v: 1,
+        //   ttl: 3600,
+        //   updated_at: 1678886400,
+        //   endpoints: [
+        //     { type: 'tcp', uri: '192.168.1.100:8080', priority: 10, family: 'ipv4' },
+        //     { type: 'onion', uri: 'vww6y4qj7y3t45b5.onion:443', priority: 20, family: 'onion' }
+        //   ],
+        //   caps: ['auth', 'upload'],
+        //   notes: 'Main chat service instance'
+        // }
+    } else {
+        console.log('Service locator not found or could not be resolved.');
+    }
+} catch (e) {
+    if (e instanceof NCC05TimeoutError) {
+        console.error('Resolution timed out:', e.message);
+    } else {
+        console.error('An error occurred during resolution:', e);
+    }
+} finally {
+    // It's good practice to close the resolver when you're done if it created its own pool.
+    // If you passed an external pool, you manage its lifecycle.
+    resolver.close(); 
+}
+
+// Close the external pool if you instantiated it.
+// pool.close();
 ```
 
-### 4. Tor & Privacy (Node.js)
+### 2. Publishing a Service Locator
 
-Route all Nostr relay traffic through a local Tor proxy (`127.0.0.1:9050`).
+You can publish a service locator using the `NCC05Publisher`. This allows you to broadcast your service's endpoints to the Nostr network, either publicly, encrypted for yourself, or encrypted for a specific recipient.
 
 ```typescript
-import { SocksProxyAgent } from 'socks-proxy-agent';
-import { WebSocket } from 'ws';
+import { NCC05Publisher, NCC05Payload } from 'ncc-05';
+import { generateSecretKey, getPublicKey, nip19 } from 'nostr-tools';
 
-class TorWebSocket extends WebSocket {
-    constructor(address: string, protocols?: string | string[]) {
-        const agent = new SocksProxyAgent('socks5h://127.0.0.1:9050');
-        super(address, protocols, { agent });
-    }
+const publisher = new NCC05Publisher();
+const relaysToPublishTo = ['wss://relay.damus.io', 'wss://relay.nostr.band'];
+
+// Your secret key (should be a hex string or Uint8Array)
+const publisherSecretKey = 'your_publisher_secret_key_hex'; 
+
+const servicePayload: NCC05Payload = {
+    v: 1, // Payload version
+    ttl: 3600, // Time-to-live in seconds
+    updated_at: Math.floor(Date.now() / 1000), // Current timestamp
+    endpoints: [
+        { type: 'tcp', uri: '1.2.3.4:8080', priority: 10, family: 'ipv4' },
+        { type: 'http', uri: 'https://myservice.com', priority: 5, family: 'ipv4' }
+    ],
+    caps: ['login', 'status'], // Optional capabilities
+    notes: 'My primary service instance' // Optional notes
+};
+
+// --- Publish a public record (not encrypted) ---
+try {
+    const publicEvent = await publisher.publish(relaysToPublishTo, publisherSecretKey, servicePayload, {
+        identifier: 'my-public-service',
+        public: true // Set to true for public, unencrypted records
+    });
+    console.log('Public record published:', publicEvent.id);
+} catch (e) {
+    console.error('Failed to publish public record:', e);
 }
 
-const resolver = new NCC05Resolver({
-    websocketImplementation: TorWebSocket
-});
+// --- Publish a record encrypted for yourself (self-encrypted) ---
+try {
+    // This record can only be decrypted by the publisherSecretKey
+    const selfEncryptedEvent = await publisher.publish(relaysToPublishTo, publisherSecretKey, servicePayload, {
+        identifier: 'my-private-service',
+        // public: false is default, recipientPubkey also defaults to publisher's pubkey
+    });
+    console.log('Self-encrypted record published:', selfEncryptedEvent.id);
+} catch (e) {
+    console.error('Failed to publish self-encrypted record:', e);
+}
+
+// --- Publish a record encrypted for a specific recipient ---
+try {
+    const recipientPubkey = getPublicKey(generateSecretKey()); // Example recipient
+    const recipientEncryptedEvent = await publisher.publish(relaysToPublishTo, publisherSecretKey, servicePayload, {
+        identifier: 'service-for-friend',
+        recipientPubkey: recipientPubkey // Encrypts content for this recipient
+    });
+    console.log('Recipient-encrypted record published:', recipientEncryptedEvent.id);
+} catch (e) {
+    console.error('Failed to publish recipient-encrypted record:', e);
+}
+
+// --- Publish a record wrapped for multiple recipients ---
+try {
+    const groupMembers = [
+        getPublicKey(generateSecretKey()), // Member 1
+        getPublicKey(generateSecretKey()), // Member 2
+    ];
+    const wrappedEvent = await publisher.publishWrapped(relaysToPublishTo, publisherSecretKey, groupMembers, servicePayload, 'shared-service');
+    console.log('Wrapped record published for multiple recipients:', wrappedEvent.id);
+} catch (e) {
+    console.error('Failed to publish wrapped record:', e);
+} finally {
+    publisher.close(relaysToPublishTo); // Close connections used by this publisher instance
+}
 ```
 
+## Error Handling
+
+The library exports specific error classes for granular handling:
+- `NCC05Error`: Base class for all NCC-05 specific errors.
+- `NCC05RelayError`: Communication failure with Nostr relays.
+- `NCC05TimeoutError`: Operation exceeded the specified timeout.
+- `NCC05DecryptionError`: Failed to decrypt the record (invalid keys or content).
+- `NCC05ArgumentError`: Invalid arguments provided (e.g., malformed keys).
+
+## Description
+
+This library implements Nostr Community Convention 05 (NCC-05) for identity-bound service locator resolution. NCC-05 defines a standard way for Nostr identities to publish and discover dynamic service endpoints (like IP addresses, ports, or Tor .onion addresses) using Nostr kind `30058` events. This allows applications to resolve a standardized service locator for a given user's Nostr public key and a specified service identifier.
+
+It integrates with [NIP-05 (Nostr Identity)](https://github.com/nostr-protocol/nips/blob/master/05.md) by allowing resolution based on NIP-05 verified identities and leveraging NIP-65 for relay discovery.
+
+## How it works
+
+NCC-05 leverages Nostr to store and retrieve service locator records. When `resolve` is called, the library performs the following steps:
+
+1.  **Identity Resolution**: Converts `npub` formatted public keys to their hexadecimal representation.
+2.  **Relay Discovery (Optional NIP-65)**: If enabled, attempts to discover additional relays from the target user's NIP-65 (kind `10002`) event, ensuring a broader search for their records.
+3.  **Querying for `kind:30058` records**: It queries known Nostr relays (bootstrap and potentially NIP-65 discovered) for `kind:30058` events authored by the target public key and matching the provided 'd' tag identifier.
+4.  **Filtering and Validation**: Discovered records are filtered for valid signatures and the correct author. The latest valid record is selected.
+5.  **Decryption**: If the content is encrypted (using NIP-44), it attempts to decrypt it using the provided secret key. It supports both single-recipient (self-encrypted or targeted) and multi-recipient "wrapped" encryption patterns.
+6.  **Payload Parsing and Validation**: The decrypted content is parsed as an `NCC05Payload` and validated for structural integrity and freshness (checking `ttl` against `updated_at`).
+7.  **Resolution**: The most appropriate and valid `NCC05Payload` is returned.
+
+## Tor & Privacy (Onion Services)
+...
 ## API Reference
 
 ### `NCC05Resolver`
-- `resolve(targetPubkey, secretKey?, identifier?, options?)`: Finds and decrypts a locator record.
-- `close()`: Closes pool connections.
+- `new NCC05Resolver(options?: ResolverOptions)`: Constructor.
+- `resolve(targetPubkey: string, secretKey?: string | Uint8Array, identifier: string = 'addr', options?: { strict?: boolean, gossip?: boolean }): Promise<NCC05Payload | null>`: Finds and decrypts a locator record.
+- `close(): void`: Closes pool connections.
 
 ### `NCC05Publisher`
-- `publish(relays, secretKey, payload, options?)`: Publishes a standard or targeted record.
-- `publishWrapped(relays, secretKey, recipients, payload, identifier?)`: Publishes a multi-recipient record.
+- `new NCC05Publisher(options?: PublisherOptions)`: Constructor.
+- `publish(relays: string[], secretKey: string | Uint8Array, payload: NCC05Payload, options?: { identifier?: string, recipientPubkey?: string, public?: boolean }): Promise<Event>`: Publishes a standard or targeted record.
+- `publishWrapped(relays: string[], secretKey: string | Uint8Array, recipients: string[], payload: NCC05Payload, identifier: string = 'addr'): Promise<Event>`: Publishes a multi-recipient record.
+- `close(relays: string[]): void`: Closes connections to specified relays.
 
 ### `NCC05Group`
 - `createGroupIdentity()`: Generates a shared group keypair.
 - `resolveAsGroup(...)`: Helper for shared-nsec resolution.
 
-## License
+### Interfaces
+
+#### `NCC05Payload`
 
+The structure of the resolved service locator data:
 
+```typescript
+export interface NCC05Payload {
+    v: number;                 // Payload version (currently 1)
+    ttl: number;               // Time-to-live in seconds
+    updated_at: number;        // Unix timestamp of the last update
+    endpoints: NCC05Endpoint[];// List of available endpoints
+    caps?: string[];           // Optional capability identifiers supported by the service
+    notes?: string;            // Optional human-readable notes
+}
+
+export interface NCC05Endpoint {
+    type: 'tcp' | 'udp' | string; // Protocol type, e.g., 'tcp', 'udp', 'http'
+    uri: string;                  // The URI string, e.g., '1.2.3.4:8080' or '[2001:db8::1]:9000'
+    priority: number;             // Priority for selection (lower is higher priority)
+    family: 'ipv4' | 'ipv6' | 'onion' | string; // Network family for routing hints
+}
+```
 
-CC0 1.0 Universal
+## License

package/dist/index.d.ts

@@ -60,8 +60,6 @@ export interface ResolverOptions {
     bootstrapRelays?: string[];
     /** Timeout for relay queries in milliseconds (default: 10000) */
     timeout?: number;
-    /** Custom WebSocket implementation (e.g., for Tor/SOCKS5 in Node.js) */
-    websocketImplementation?: any;
     /** Existing SimplePool instance to share connections */
     pool?: SimplePool;
 }
@@ -69,8 +67,6 @@ export interface ResolverOptions {
  * Options for configuring the NCC05Publisher.
  */
 export interface PublisherOptions {
-    /** Custom WebSocket implementation */
-    websocketImplementation?: any;
     /** Existing SimplePool instance */
     pool?: SimplePool;
     /** Timeout for publishing in milliseconds (default: 5000) */
@@ -118,6 +114,7 @@ export declare class NCC05Group {
  */
 export declare class NCC05Resolver {
     private pool;
+    private _ownPool;
     private bootstrapRelays;
     private timeout;
     /**
@@ -143,7 +140,7 @@ export declare class NCC05Resolver {
         gossip?: boolean;
     }): Promise<NCC05Payload | null>;
     /**
-     * Closes connections to all relays in the pool.
+     * Closes connections to all relays in the pool if managed internally.
      */
     close(): void;
 }
@@ -152,6 +149,7 @@ export declare class NCC05Resolver {
  */
 export declare class NCC05Publisher {
     private pool;
+    private _ownPool;
     private timeout;
     /**
      * @param options - Configuration for the publisher.
@@ -185,7 +183,7 @@ export declare class NCC05Publisher {
         public?: boolean;
     }): Promise<Event>;
     /**
-     * Closes connections to the specified relays.
+     * Closes connections to the specified relays if managed internally.
      */
     close(relays: string[]): void;
 }

package/dist/index.js

@@ -51,12 +51,6 @@ function ensureUint8Array(key) {
     }
     throw new NCC05ArgumentError("Key must be a hex string or Uint8Array");
 }
-function getHexPubkey(key) {
-    if (key instanceof Uint8Array) {
-        return Array.from(key).map(b => b.toString(16).padStart(2, '0')).join('');
-    }
-    return key;
-}
 /**
  * Utility for managing shared group access to service records.
  */
@@ -95,24 +89,15 @@ export class NCC05Group {
  */
 export class NCC05Resolver {
     pool;
+    _ownPool;
     bootstrapRelays;
     timeout;
     /**
      * @param options - Configuration for the resolver.
      */
     constructor(options = {}) {
+        this._ownPool = !options.pool;
         this.pool = options.pool || new SimplePool();
-        if (!options.pool) {
-            if (options.websocketImplementation) {
-                // @ts-ignore - Patching pool for custom transport
-                this.pool.websocketImplementation = options.websocketImplementation;
-            }
-            else if (typeof globalThis !== 'undefined' && !globalThis.WebSocket) {
-                // In Node.js environment without global WebSocket, this might fail later.
-                // We leave it to the user or nostr-tools to handle, but this logic
-                // allows 'websocketImplementation' to be explicitly checked.
-            }
-        }
         this.bootstrapRelays = options.bootstrapRelays || ['wss://relay.damus.io', 'wss://nos.lol'];
         this.timeout = options.timeout || 10000;
     }
@@ -201,7 +186,7 @@ export class NCC05Resolver {
                         return null; // Not intended for us
                     }
                 }
-                catch (e) {
+                catch (_e) {
                     throw new NCC05DecryptionError("Failed to decrypt wrapped content");
                 }
             }
@@ -211,7 +196,7 @@ export class NCC05Resolver {
                     const conversationKey = nip44.getConversationKey(sk, hexPubkey);
                     content = nip44.decrypt(latestEvent.content, conversationKey);
                 }
-                catch (e) {
+                catch (_e) {
                     throw new NCC05DecryptionError("Failed to decrypt content");
                 }
             }
@@ -220,7 +205,7 @@ export class NCC05Resolver {
             try {
                 payload = JSON.parse(content);
             }
-            catch (e) {
+            catch (_e) {
                 return null; // Invalid JSON
             }
             if (!payload || !payload.endpoints || !Array.isArray(payload.endpoints)) {
@@ -242,14 +227,12 @@ export class NCC05Resolver {
         }
     }
     /**
-     * Closes connections to all relays in the pool.
+     * Closes connections to all relays in the pool if managed internally.
      */
     close() {
-        // If we didn't create the pool, we probably shouldn't close it?
-        // But the previous implementation did.
-        // We will only close bootstrap relays to be safe if sharing pool.
-        // Actually, pool.close() takes args.
-        this.pool.close(this.bootstrapRelays);
+        if (this._ownPool) {
+            this.pool.close(this.bootstrapRelays);
+        }
     }
 }
 /**
@@ -257,16 +240,14 @@ export class NCC05Resolver {
  */
 export class NCC05Publisher {
     pool;
+    _ownPool;
     timeout;
     /**
      * @param options - Configuration for the publisher.
      */
     constructor(options = {}) {
+        this._ownPool = !options.pool;
         this.pool = options.pool || new SimplePool();
-        if (!options.pool && options.websocketImplementation) {
-            // @ts-ignore
-            this.pool.websocketImplementation = options.websocketImplementation;
-        }
         this.timeout = options.timeout || 5000;
     }
     async _publishToRelays(relays, signedEvent) {
@@ -361,9 +342,11 @@ export class NCC05Publisher {
         return signedEvent;
     }
     /**
-     * Closes connections to the specified relays.
+     * Closes connections to the specified relays if managed internally.
      */
     close(relays) {
-        this.pool.close(relays);
+        if (this._ownPool) {
+            this.pool.close(relays);
+        }
     }
 }

package/dist/mock-relay.d.ts

@@ -1,6 +1,10 @@
+import { WebSocket } from 'ws';
 export declare class MockRelay {
+    private static instance;
     private wss;
     private events;
     constructor(port?: number);
     stop(): void;
+    static getNostrConnections(): WebSocket[];
+    static closeAllClientConnections(): void;
 }

package/dist/mock-relay.js

@@ -1,9 +1,11 @@
-import { WebSocketServer } from 'ws';
+import { WebSocketServer, WebSocket } from 'ws';
 export class MockRelay {
+    static instance;
     wss;
     events = [];
     constructor(port = 8080) {
         this.wss = new WebSocketServer({ port });
+        MockRelay.instance = this;
         this.wss.on('connection', (ws) => {
             ws.on('message', (data) => {
                 const msg = JSON.parse(data);
@@ -44,4 +46,19 @@ export class MockRelay {
     stop() {
         this.wss.close();
     }
+    static getNostrConnections() {
+        if (!MockRelay.instance) {
+            return [];
+        }
+        return Array.from(MockRelay.instance.wss.clients);
+    }
+    static closeAllClientConnections() {
+        if (MockRelay.instance) {
+            MockRelay.instance.wss.clients.forEach(client => {
+                if (client.readyState === WebSocket.OPEN) {
+                    client.close();
+                }
+            });
+        }
+    }
 }

package/dist/test-lifecycle.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test-lifecycle.js

@@ -0,0 +1,33 @@
+import { NCC05Resolver } from './index.js';
+import { SimplePool } from 'nostr-tools';
+async function testLifecycle() {
+    console.log('--- Starting Lifecycle Test ---');
+    // 1. Internal Pool Management
+    console.log('Test 1: Internal Pool (should close)');
+    const resolverInternal = new NCC05Resolver();
+    // @ts-ignore - Access private property for testing or infer from behavior
+    const internalPool = resolverInternal['pool'];
+    internalPool.close = (_relays) => {
+        console.log('Internal pool close called.');
+    };
+    resolverInternal.close(); // Should log
+    // 2. Shared Pool Management
+    console.log('Test 2: Shared Pool (should NOT close)');
+    const sharedPool = new SimplePool();
+    let sharedClosed = false;
+    sharedPool.close = (_relays) => {
+        sharedClosed = true;
+        console.error('ERROR: Shared pool was closed!');
+    };
+    const resolverShared = new NCC05Resolver({ pool: sharedPool });
+    resolverShared.close(); // Should NOT close sharedPool
+    if (!sharedClosed) {
+        console.log('Shared pool correctly remained open.');
+    }
+    else {
+        process.exit(1);
+    }
+    console.log('Lifecycle Test Suite Passed.');
+    process.exit(0);
+}
+testLifecycle().catch(console.error);

package/dist/test-new.js

@@ -1,4 +1,4 @@
-import { NCC05Publisher, NCC05Resolver } from './index.js';
+import { NCC05Publisher, NCC05Resolver, NCC05TimeoutError } from './index.js';
 import { generateSecretKey, getPublicKey, SimplePool } from 'nostr-tools';
 import { MockRelay } from './mock-relay.js';
 import { WebSocketServer } from 'ws';
@@ -73,7 +73,7 @@ async function testNewFeatures() {
     }
     catch (e) {
         const duration = Date.now() - start;
-        if (e.name === 'NCC05TimeoutError') {
+        if (e instanceof NCC05TimeoutError) {
             console.log(`Timed out as expected in ${duration}ms: OK`);
         }
         else {

package/eslint.config.mjs

@@ -0,0 +1,25 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default [
+  {files: ["**/*.{js,mjs,cjs,ts}"]},
+  {languageOptions: { globals: globals.node }},
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+      rules: {
+          "@typescript-eslint/no-explicit-any": "off",
+          "@typescript-eslint/ban-ts-comment": "off",
+          "@typescript-eslint/no-unused-vars": ["warn", { 
+              "argsIgnorePattern": "^_",
+              "varsIgnorePattern": "^_",
+              "caughtErrorsIgnorePattern": "^_"
+          }],
+          "no-console": "off"
+      }
+  },
+  {
+      ignores: ["dist/", "node_modules/"]
+  }
+];

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "ncc-05",
-  "version": "1.1.5",
+  "version": "1.1.8",
   "description": "Nostr Community Convention 05 - Identity-Bound Service Locator Resolution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
     "build": "tsc",
+    "lint": "eslint src/**/*.ts",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -22,9 +23,15 @@
     "nostr-tools": "^2.10.0"
   },
   "devDependencies": {
+    "@eslint/js": "^9.39.2",
     "@types/node": "^25.0.3",
     "@types/ws": "^8.18.1",
+    "@typescript-eslint/eslint-plugin": "^8.50.1",
+    "@typescript-eslint/parser": "^8.50.1",
+    "eslint": "^9.39.2",
+    "globals": "^16.5.0",
     "typescript": "^5.0.0",
+    "typescript-eslint": "^8.50.1",
     "ws": "^8.18.3"
   }
 }

package/src/index.ts

@@ -69,13 +69,6 @@ function ensureUint8Array(key: string | Uint8Array): Uint8Array {
     throw new NCC05ArgumentError("Key must be a hex string or Uint8Array");
 }
 
-function getHexPubkey(key: string | Uint8Array): string {
-    if (key instanceof Uint8Array) {
-        return Array.from(key).map(b => b.toString(16).padStart(2, '0')).join('');
-    }
-    return key;
-}
-
 /**
  * Represents a single reachable service endpoint.
  */
@@ -116,8 +109,6 @@ export interface ResolverOptions {
     bootstrapRelays?: string[];
     /** Timeout for relay queries in milliseconds (default: 10000) */
     timeout?: number;
-    /** Custom WebSocket implementation (e.g., for Tor/SOCKS5 in Node.js) */
-    websocketImplementation?: any;
     /** Existing SimplePool instance to share connections */
     pool?: SimplePool;
 }
@@ -126,8 +117,6 @@ export interface ResolverOptions {
  * Options for configuring the NCC05Publisher.
  */
 export interface PublisherOptions {
-    /** Custom WebSocket implementation */
-    websocketImplementation?: any;
     /** Existing SimplePool instance */
     pool?: SimplePool;
     /** Timeout for publishing in milliseconds (default: 5000) */
@@ -190,6 +179,7 @@ export class NCC05Group {
  */
 export class NCC05Resolver {
     private pool: SimplePool;
+    private _ownPool: boolean;
     private bootstrapRelays: string[];
     private timeout: number;
 
@@ -197,19 +187,8 @@ export class NCC05Resolver {
      * @param options - Configuration for the resolver.
      */
     constructor(options: ResolverOptions = {}) {
+        this._ownPool = !options.pool;
         this.pool = options.pool || new SimplePool();
-        
-        if (!options.pool) {
-            if (options.websocketImplementation) {
-                // @ts-ignore - Patching pool for custom transport
-                this.pool.websocketImplementation = options.websocketImplementation;
-            } else if (typeof globalThis !== 'undefined' && !globalThis.WebSocket) {
-                // In Node.js environment without global WebSocket, this might fail later.
-                // We leave it to the user or nostr-tools to handle, but this logic
-                // allows 'websocketImplementation' to be explicitly checked.
-            }
-        }
-
         this.bootstrapRelays = options.bootstrapRelays || ['wss://relay.damus.io', 'wss://nos.lol'];
         this.timeout = options.timeout || 10000;
     }
@@ -320,7 +299,7 @@ export class NCC05Resolver {
                     } else {
                         return null; // Not intended for us
                     }
-                } catch (e) {
+                } catch (_e) {
                     throw new NCC05DecryptionError("Failed to decrypt wrapped content");
                 }
             } else if (sk && !content.startsWith('{')) {
@@ -328,7 +307,7 @@ export class NCC05Resolver {
                 try {
                     const conversationKey = nip44.getConversationKey(sk, hexPubkey);
                     content = nip44.decrypt(latestEvent.content, conversationKey);
-                } catch (e) {
+                } catch (_e) {
                      throw new NCC05DecryptionError("Failed to decrypt content");
                 }
             }
@@ -337,7 +316,7 @@ export class NCC05Resolver {
             let payload: NCC05Payload;
             try {
                 payload = JSON.parse(content) as NCC05Payload;
-            } catch (e) {
+            } catch (_e) {
                 return null; // Invalid JSON
             }
 
@@ -360,14 +339,12 @@ export class NCC05Resolver {
     }
 
     /**
-     * Closes connections to all relays in the pool.
+     * Closes connections to all relays in the pool if managed internally.
      */
     close() {
-        // If we didn't create the pool, we probably shouldn't close it?
-        // But the previous implementation did.
-        // We will only close bootstrap relays to be safe if sharing pool.
-        // Actually, pool.close() takes args.
-        this.pool.close(this.bootstrapRelays);
+        if (this._ownPool) {
+            this.pool.close(this.bootstrapRelays);
+        }
     }
 }
 
@@ -376,17 +353,15 @@ export class NCC05Resolver {
  */
 export class NCC05Publisher {
     private pool: SimplePool;
+    private _ownPool: boolean;
     private timeout: number;
 
     /**
      * @param options - Configuration for the publisher.
      */
     constructor(options: PublisherOptions = {}) {
+        this._ownPool = !options.pool;
         this.pool = options.pool || new SimplePool();
-        if (!options.pool && options.websocketImplementation) {
-            // @ts-ignore
-            this.pool.websocketImplementation = options.websocketImplementation;
-        }
         this.timeout = options.timeout || 5000;
     }
 
@@ -508,9 +483,11 @@ export class NCC05Publisher {
     }
 
     /**
-     * Closes connections to the specified relays.
+     * Closes connections to the specified relays if managed internally.
      */
     close(relays: string[]) {
-        this.pool.close(relays);
+        if (this._ownPool) {
+            this.pool.close(relays);
+        }
     }
 }

package/src/mock-relay.ts

@@ -1,11 +1,13 @@
 import { WebSocketServer, WebSocket } from 'ws';
 
 export class MockRelay {
+    private static instance: MockRelay;
     private wss: WebSocketServer;
     private events: any[] = [];
 
     constructor(port: number = 8080) {
         this.wss = new WebSocketServer({ port });
+        MockRelay.instance = this;
         this.wss.on('connection', (ws: WebSocket) => {
             ws.on('message', (data: string) => {
                 const msg = JSON.parse(data);
@@ -48,4 +50,21 @@ export class MockRelay {
     stop() {
         this.wss.close();
     }
+
+    public static getNostrConnections(): WebSocket[] {
+        if (!MockRelay.instance) {
+            return [];
+        }
+        return Array.from(MockRelay.instance.wss.clients);
+    }
+
+    public static closeAllClientConnections() {
+        if (MockRelay.instance) {
+            MockRelay.instance.wss.clients.forEach(client => {
+                if (client.readyState === WebSocket.OPEN) {
+                    client.close();
+                }
+            });
+        }
+    }
 }

package/src/test-lifecycle.ts

@@ -0,0 +1,40 @@
+import { NCC05Resolver } from './index.js';
+import { SimplePool } from 'nostr-tools';
+
+async function testLifecycle() {
+    console.log('--- Starting Lifecycle Test ---');
+    
+    // 1. Internal Pool Management
+    console.log('Test 1: Internal Pool (should close)');
+    const resolverInternal = new NCC05Resolver();
+    // @ts-ignore - Access private property for testing or infer from behavior
+    const internalPool = resolverInternal['pool'];
+    internalPool.close = (_relays?: string[]) => {
+        console.log('Internal pool close called.');
+    };
+    
+    resolverInternal.close(); // Should log
+
+    // 2. Shared Pool Management
+    console.log('Test 2: Shared Pool (should NOT close)');
+    const sharedPool = new SimplePool();
+    let sharedClosed = false;
+    sharedPool.close = (_relays?: string[]) => {
+        sharedClosed = true;
+        console.error('ERROR: Shared pool was closed!');
+    };
+
+    const resolverShared = new NCC05Resolver({ pool: sharedPool });
+    resolverShared.close(); // Should NOT close sharedPool
+
+    if (!sharedClosed) {
+        console.log('Shared pool correctly remained open.');
+    } else {
+        process.exit(1);
+    }
+    
+    console.log('Lifecycle Test Suite Passed.');
+    process.exit(0);
+}
+
+testLifecycle().catch(console.error);

package/src/test-new.ts

@@ -76,9 +76,9 @@ async function testNewFeatures() {
         console.error('Should have timed out!');
         wss.close();
         process.exit(1);
-    } catch (e: any) {
+    } catch (e) {
         const duration = Date.now() - start;
-        if (e.name === 'NCC05TimeoutError') {
+        if (e instanceof NCC05TimeoutError) {
             console.log(`Timed out as expected in ${duration}ms: OK`);
         } else {
             console.error('Caught unexpected error:', e);