ncc-06-js 0.4.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ncc-06-js",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Reusable NCC-06 discovery helpers for multimodal service identities.",
   "type": "module",
   "main": "src/index.js",

package/src/keys.js

@@ -1,6 +1,8 @@
-import { generateSecretKey, getPublicKey } from 'nostr-tools/pure';
+import { generateSecretKey, getPublicKey as getPk } from 'nostr-tools/pure';
 import { nip19 } from 'nostr-tools';
 
+export const getPublicKey = getPk;
+
 /**
  * Generate a deterministic keypair, returning all common formats.
  */

package/src/resolver.js

@@ -1,6 +1,7 @@
 import WebSocket from 'ws';
+import { SimplePool } from 'nostr-tools';
 import { NCC05Resolver } from 'ncc-05-js';
-import { NCC02Resolver } from 'ncc-02-js';
+import { validateNcc02, parseNcc02Tags } from './ncc02.js';
 import { validateLocatorFreshness, normalizeLocatorEndpoints } from './ncc05.js';
 import { choosePreferredEndpoint } from './selector.js';
 
@@ -39,22 +40,54 @@ export async function resolveServiceEndpoint(options = {}) {
     throw new Error('At least one bootstrap relay is required');
   }
 
+  // 1. Resolve NCC-02 Service Record
   const timestamp = now ?? Math.floor(Date.now() / 1000);
   const locatorResolver = resolveLocator ?? defaultResolveLocator;
 
-  // 1. Resolve NCC-02 Service Record using the library
   let serviceRecord;
-  const resolver = ncc02Resolver || new NCC02Resolver(bootstrapRelays, { pool });
-  try {
-    serviceRecord = await resolver.resolve(servicePubkey, serviceId, {});
-  } catch (err) {
-    throw err;
-  } finally {
-    if (!ncc02Resolver) {
-      resolver.close();
+  if (ncc02Resolver) {
+    serviceRecord = await ncc02Resolver.resolve(servicePubkey, serviceId, {});
+  } else {
+    const poolToUse = pool || new SimplePool();
+    try {
+      const filters = [{
+        kinds: [30059],
+        authors: [servicePubkey],
+        '#d': [serviceId]
+      }];
+      const events = await new Promise((resolve) => {
+        const results = [];
+        const sub = poolToUse.subscribeMany(bootstrapRelays, filters, {
+          onevent(e) { results.push(e); },
+          oneose() { sub.close(); resolve(results); }
+        });
+        setTimeout(() => { sub.close(); resolve(results); }, publicationRelayTimeoutMs);
+      });
+
+      // Sort and validate
+      const validEvents = events
+        .filter(e => validateNcc02(e, { expectedAuthor: servicePubkey, expectedD: serviceId, now: timestamp }))
+        .sort((a, b) => b.created_at - a.created_at);
+      
+      if (validEvents[0]) {
+        const tags = parseNcc02Tags(validEvents[0]);
+        serviceRecord = {
+          endpoint: tags.u,
+          fingerprint: tags.k,
+          expiry: Number(tags.exp),
+          eventId: validEvents[0].id,
+          pubkey: validEvents[0].pubkey
+        };
+      }
+    } finally {
+      if (!pool) poolToUse.close(bootstrapRelays);
     }
   }
   
+  if (!serviceRecord) {
+    throw new Error(`No valid NCC-02 record found for ${serviceId}`);
+  }
+  
   // 2. Resolve NCC-05 Locator
   const locatorPayload = await locatorResolver({
     bootstrapRelays,
@@ -156,7 +189,9 @@ async function defaultResolveLocator({
       gossip: false
     });
   } finally {
-    resolver.close();
+    if (resolver && typeof resolver.close === 'function') {
+      resolver.close();
+    }
   }
 }
 

package/src/tls.js

@@ -32,15 +32,22 @@ export async function ensureSelfSignedCert({
     return { type: 2, value: name };
   });
 
-  const generated = selfsigned.generate(attrs, {
+  const generated = await selfsigned.generate(attrs, {
     algorithm: 'rsa',
     keySize: 2048,
     days: 365,
     extensions: [{ name: 'subjectAltName', altNames: altNameObjects }]
   });
 
-  fs.writeFileSync(keyPath, generated.private, 'utf-8');
-  fs.writeFileSync(certPath, generated.cert, 'utf-8');
+  const privateKey = generated.private || generated.privateKey;
+  const certificate = generated.cert || generated.certificate;
+
+  if (!privateKey || !certificate) {
+    throw new Error(`Self-signed cert generation failed. Keys returned: ${Object.keys(generated).join(', ')}`);
+  }
+
+  fs.writeFileSync(keyPath, privateKey, 'utf-8');
+  fs.writeFileSync(certPath, certificate, 'utf-8');
 
   return { keyPath, certPath };
 }