ncc-05 1.0.0 → 1.1.1

package/dist/index.d.ts

@@ -18,16 +18,33 @@ export interface ResolverOptions {
     timeout?: number;
     websocketImplementation?: any;
 }
+/**
+ * Advanced multi-recipient "wrapping" structure.
+ */
+export interface WrappedContent {
+    /** The actual payload encrypted with a random symmetric key */
+    ciphertext: string;
+    /** Map of recipient pubkey -> wrapped symmetric key */
+    wraps: Record<string, string>;
+}
+export declare class NCC05Group {
+    static createGroupIdentity(): {
+        nsec: `nsec1${string}`;
+        sk: Uint8Array<ArrayBufferLike>;
+        pk: string;
+        npub: `npub1${string}`;
+    };
+    /**
+     * Resolve a record that was published using a group's shared identity.
+     */
+    static resolveAsGroup(resolver: NCC05Resolver, groupPubkey: string, groupSecretKey: Uint8Array, identifier?: string): Promise<NCC05Payload | null>;
+}
 export declare class NCC05Resolver {
     private pool;
     private bootstrapRelays;
     private timeout;
     constructor(options?: ResolverOptions);
-    /**
-     * Resolve a locator record for a given pubkey.
-     * Supports both hex and npub strings.
-     */
-    resolve(targetPubkey: string, secretKey: Uint8Array, identifier?: string, options?: {
+    resolve(targetPubkey: string, secretKey?: Uint8Array, identifier?: string, options?: {
         strict?: boolean;
         gossip?: boolean;
     }): Promise<NCC05Payload | null>;
@@ -38,9 +55,11 @@ export declare class NCC05Publisher {
     constructor(options?: {
         websocketImplementation?: any;
     });
-    /**
-     * Create and publish a locator record.
-     */
-    publish(relays: string[], secretKey: Uint8Array, payload: NCC05Payload, identifier?: string): Promise<Event>;
+    publishWrapped(relays: string[], secretKey: Uint8Array, recipients: string[], payload: NCC05Payload, identifier?: string): Promise<Event>;
+    publish(relays: string[], secretKey: Uint8Array, payload: NCC05Payload, options?: {
+        identifier?: string;
+        recipientPubkey?: string;
+        public?: boolean;
+    }): Promise<Event>;
     close(relays: string[]): void;
 }

package/dist/index.js

@@ -1,4 +1,22 @@
-import { SimplePool, nip44, nip19, finalizeEvent, verifyEvent, getPublicKey } from 'nostr-tools';
+import { SimplePool, nip44, nip19, finalizeEvent, verifyEvent, getPublicKey, generateSecretKey } from 'nostr-tools';
+export class NCC05Group {
+    static createGroupIdentity() {
+        const sk = generateSecretKey();
+        const pk = getPublicKey(sk);
+        return {
+            nsec: nip19.nsecEncode(sk),
+            sk: sk,
+            pk: pk,
+            npub: nip19.npubEncode(pk)
+        };
+    }
+    /**
+     * Resolve a record that was published using a group's shared identity.
+     */
+    static async resolveAsGroup(resolver, groupPubkey, groupSecretKey, identifier = 'addr') {
+        return resolver.resolve(groupPubkey, groupSecretKey, identifier);
+    }
+}
 export class NCC05Resolver {
     pool;
     bootstrapRelays;
@@ -6,16 +24,12 @@ export class NCC05Resolver {
     constructor(options = {}) {
         this.pool = new SimplePool();
         if (options.websocketImplementation) {
-            // @ts-ignore - Patching pool for custom WebSocket (Tor/Proxy)
+            // @ts-ignore
             this.pool.websocketImplementation = options.websocketImplementation;
         }
         this.bootstrapRelays = options.bootstrapRelays || ['wss://relay.damus.io', 'wss://nos.lol'];
         this.timeout = options.timeout || 10000;
     }
-    /**
-     * Resolve a locator record for a given pubkey.
-     * Supports both hex and npub strings.
-     */
     async resolve(targetPubkey, secretKey, identifier = 'addr', options = {}) {
         let hexPubkey = targetPubkey;
         if (targetPubkey.startsWith('npub1')) {
@@ -23,7 +37,6 @@ export class NCC05Resolver {
             hexPubkey = decoded.data;
         }
         let queryRelays = [...this.bootstrapRelays];
-        // 1. NIP-65 Gossip Discovery
         if (options.gossip) {
             const relayListEvent = await this.pool.get(this.bootstrapRelays, {
                 authors: [hexPubkey],
@@ -33,9 +46,7 @@ export class NCC05Resolver {
                 const discoveredRelays = relayListEvent.tags
                     .filter(t => t[0] === 'r')
                     .map(t => t[1]);
-                if (discoveredRelays.length > 0) {
-                    queryRelays = [...new Set([...queryRelays, ...discoveredRelays])];
-                }
+                queryRelays = [...new Set([...queryRelays, ...discoveredRelays])];
             }
         }
         const filter = {
@@ -45,77 +56,103 @@ export class NCC05Resolver {
             limit: 10
         };
         const queryPromise = this.pool.querySync(queryRelays, filter);
-        const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(null), this.timeout));
+        const timeoutPromise = new Promise((r) => setTimeout(() => r(null), this.timeout));
         const result = await Promise.race([queryPromise, timeoutPromise]);
         if (!result || (Array.isArray(result) && result.length === 0))
             return null;
-        // 2. Filter for valid signatures and sort by created_at
         const validEvents = result
             .filter(e => verifyEvent(e))
             .sort((a, b) => b.created_at - a.created_at);
         if (validEvents.length === 0)
             return null;
         const latestEvent = validEvents[0];
-        // 2. Decrypt
         try {
-            const conversationKey = nip44.getConversationKey(secretKey, hexPubkey);
-            const decrypted = nip44.decrypt(latestEvent.content, conversationKey);
-            const payload = JSON.parse(decrypted);
-            // 3. Basic Validation
-            if (!payload.endpoints || !Array.isArray(payload.endpoints)) {
-                console.error('Invalid NCC-05 payload structure');
-                return null;
+            let content = latestEvent.content;
+            // 1. Try to detect if it's a "Wrapped" multi-recipient event
+            if (content.includes('"wraps"') && secretKey) {
+                const wrapped = JSON.parse(content);
+                const myPk = getPublicKey(secretKey);
+                const myWrap = wrapped.wraps[myPk];
+                if (myWrap) {
+                    const conversationKey = nip44.getConversationKey(secretKey, hexPubkey);
+                    const symmetricKeyHex = nip44.decrypt(myWrap, conversationKey);
+                    // Convert hex symmetric key back to Uint8Array for NIP-44 decryption
+                    const symmetricKey = new Uint8Array(symmetricKeyHex.match(/.{1,2}/g).map(byte => parseInt(byte, 16)));
+                    // The payload was self-encrypted by the publisher with the session key
+                    const sessionConversationKey = nip44.getConversationKey(symmetricKey, getPublicKey(symmetricKey));
+                    content = nip44.decrypt(wrapped.ciphertext, sessionConversationKey);
+                }
             }
-            // 4. Freshness check
+            else if (secretKey) {
+                const conversationKey = nip44.getConversationKey(secretKey, hexPubkey);
+                content = nip44.decrypt(latestEvent.content, conversationKey);
+            }
+            const payload = JSON.parse(content);
+            if (!payload.endpoints)
+                return null;
             const now = Math.floor(Date.now() / 1000);
             if (now > payload.updated_at + payload.ttl) {
-                if (options.strict) {
-                    console.warn('Rejecting expired NCC-05 record (strict mode)');
+                if (options.strict)
                     return null;
-                }
-                console.warn('NCC-05 record has expired');
+                console.warn('NCC-05 record expired');
             }
             return payload;
         }
         catch (e) {
-            console.error('Failed to decrypt or parse NCC-05 record:', e);
             return null;
         }
     }
-    close() {
-        this.pool.close(this.bootstrapRelays);
-    }
+    close() { this.pool.close(this.bootstrapRelays); }
 }
 export class NCC05Publisher {
     pool;
     constructor(options = {}) {
         this.pool = new SimplePool();
         if (options.websocketImplementation) {
-            // @ts-ignore - Patching pool for custom WebSocket (Tor/Proxy)
+            // @ts-ignore
             this.pool.websocketImplementation = options.websocketImplementation;
         }
     }
-    /**
-     * Create and publish a locator record.
-     */
-    async publish(relays, secretKey, payload, identifier = 'addr') {
-        const pubkey = getPublicKey(secretKey);
-        // 1. Encrypt
-        const conversationKey = nip44.getConversationKey(secretKey, pubkey);
-        const encryptedContent = nip44.encrypt(JSON.stringify(payload), conversationKey);
-        // 2. Create and Finalize Event
+    async publishWrapped(relays, secretKey, recipients, payload, identifier = 'addr') {
+        const sessionKey = generateSecretKey();
+        const sessionKeyHex = Array.from(sessionKey).map(b => b.toString(16).padStart(2, '0')).join('');
+        const selfConversation = nip44.getConversationKey(sessionKey, getPublicKey(sessionKey));
+        const ciphertext = nip44.encrypt(JSON.stringify(payload), selfConversation);
+        const wraps = {};
+        for (const rPk of recipients) {
+            const conversationKey = nip44.getConversationKey(secretKey, rPk);
+            wraps[rPk] = nip44.encrypt(sessionKeyHex, conversationKey);
+        }
+        const wrappedContent = { ciphertext, wraps };
         const eventTemplate = {
             kind: 30058,
             created_at: Math.floor(Date.now() / 1000),
             tags: [['d', identifier]],
-            content: encryptedContent,
+            content: JSON.stringify(wrappedContent),
         };
         const signedEvent = finalizeEvent(eventTemplate, secretKey);
-        // 3. Publish
         await Promise.all(this.pool.publish(relays, signedEvent));
         return signedEvent;
     }
-    close(relays) {
-        this.pool.close(relays);
+    async publish(relays, secretKey, payload, options = {}) {
+        const myPubkey = getPublicKey(secretKey);
+        const identifier = options.identifier || 'addr';
+        let content = JSON.stringify(payload);
+        if (!options.public) {
+            const encryptionTarget = options.recipientPubkey || myPubkey;
+            const conversationKey = nip44.getConversationKey(secretKey, encryptionTarget);
+            content = nip44.encrypt(content, conversationKey);
+        }
+        const eventTemplate = {
+            kind: 30058,
+            created_at: Math.floor(Date.now() / 1000),
+            pubkey: myPubkey,
+            tags: [['d', identifier]],
+            content: content,
+        };
+        const signedEvent = finalizeEvent(eventTemplate, secretKey);
+        await Promise.all(this.pool.publish(relays, signedEvent));
+        return signedEvent;
     }
+    close(relays) { this.pool.close(relays); }
 }

package/dist/mock-relay.d.ts

@@ -0,0 +1,6 @@
+export declare class MockRelay {
+    private wss;
+    private events;
+    constructor(port?: number);
+    stop(): void;
+}

package/dist/mock-relay.js

@@ -0,0 +1,47 @@
+import { WebSocketServer } from 'ws';
+export class MockRelay {
+    wss;
+    events = [];
+    constructor(port = 8080) {
+        this.wss = new WebSocketServer({ port });
+        this.wss.on('connection', (ws) => {
+            ws.on('message', (data) => {
+                const msg = JSON.parse(data);
+                const type = msg[0];
+                if (type === 'EVENT') {
+                    const event = msg[1];
+                    // Basic replaceable logic for test consistency
+                    if (event.kind === 30058 || event.kind === 10002) {
+                        const dTag = event.tags.find((t) => t[0] === 'd')?.[1] || "";
+                        this.events = this.events.filter(e => !(e.pubkey === event.pubkey && e.kind === event.kind && (e.tags.find((t) => t[0] === 'd')?.[1] || "") === dTag));
+                    }
+                    this.events.push(event);
+                    ws.send(JSON.stringify(["OK", event.id, true, ""]));
+                }
+                else if (type === 'REQ') {
+                    const subId = msg[1];
+                    const filters = msg[2];
+                    this.events.forEach(event => {
+                        let match = true;
+                        if (filters.authors && !filters.authors.includes(event.pubkey))
+                            match = false;
+                        if (filters.kinds && !filters.kinds.includes(event.kind))
+                            match = false;
+                        if (filters['#d']) {
+                            const dTag = event.tags.find((t) => t[0] === 'd')?.[1];
+                            if (!filters['#d'].includes(dTag))
+                                match = false;
+                        }
+                        if (match) {
+                            ws.send(JSON.stringify(["EVENT", subId, event]));
+                        }
+                    });
+                    ws.send(JSON.stringify(["EOSE", subId]));
+                }
+            });
+        });
+    }
+    stop() {
+        this.wss.close();
+    }
+}

package/dist/test.js

@@ -1,9 +1,12 @@
-import { NCC05Publisher, NCC05Resolver } from './index.js';
-import { generateSecretKey, getPublicKey } from 'nostr-tools';
+import { NCC05Publisher, NCC05Resolver, NCC05Group } from './index.js';
+import { generateSecretKey, getPublicKey, nip19 } from 'nostr-tools';
+import { MockRelay } from './mock-relay.js';
 async function test() {
+    console.log('Starting Mock Relay...');
+    const relay = new MockRelay(8080);
+    const relays = ['ws://localhost:8080'];
     const sk = generateSecretKey();
     const pk = getPublicKey(sk);
-    const relays = ['wss://relay.damus.io'];
     const publisher = new NCC05Publisher();
     const resolver = new NCC05Resolver({ bootstrapRelays: relays });
     const payload = {
@@ -23,7 +26,8 @@ async function test() {
         console.log('Successfully resolved:', JSON.stringify(resolved, null, 2));
     }
     else {
-        console.log('Failed to resolve.');
+        console.error('FAILED: resolution.');
+        process.exit(1);
     }
     // Test Strict Mode with Expired Record
     console.log('Testing expired record in strict mode...');
@@ -33,7 +37,7 @@ async function test() {
         updated_at: Math.floor(Date.now() / 1000) - 10, // 10s ago
         endpoints: [{ type: 'tcp', uri: '1.1.1.1:1', priority: 1, family: 'ipv4' }]
     };
-    await publisher.publish(relays, sk, expiredPayload, 'expired-test');
+    await publisher.publish(relays, sk, expiredPayload, { identifier: 'expired-test' });
     const strictResult = await resolver.resolve(pk, sk, 'expired-test', { strict: true });
     if (strictResult === null) {
         console.log('Correctly rejected expired record in strict mode.');
@@ -44,8 +48,6 @@ async function test() {
     }
     // Test Gossip Mode
     console.log('Testing Gossip discovery...');
-    // In this test, we just point kind:10002 to the same relay we are using
-    // to verify the code path executes.
     const relayListTemplate = {
         kind: 10002,
         created_at: Math.floor(Date.now() / 1000),
@@ -53,6 +55,7 @@ async function test() {
         content: '',
     };
     const signedRL = (await import('nostr-tools')).finalizeEvent(relayListTemplate, sk);
+    // @ts-ignore
     await Promise.all(publisher['pool'].publish(relays, signedRL));
     const gossipResult = await resolver.resolve(pk, sk, 'addr', { gossip: true });
     if (gossipResult) {
@@ -64,7 +67,7 @@ async function test() {
     }
     // Test npub resolution
     console.log('Testing npub resolution...');
-    const npub = (await import('nostr-tools')).nip19.npubEncode(pk);
+    const npub = nip19.npubEncode(pk);
     const npubResult = await resolver.resolve(npub, sk);
     if (npubResult) {
         console.log('npub resolution successful.');
@@ -73,8 +76,76 @@ async function test() {
         console.error('FAILED: npub resolution did not find record.');
         process.exit(1);
     }
+    // Test Friend-to-Friend resolution
+    console.log('Testing Friend-to-Friend resolution...');
+    const skA = generateSecretKey();
+    const pkA = getPublicKey(skA);
+    const skB = generateSecretKey();
+    const pkB = getPublicKey(skB);
+    const payloadFriend = {
+        v: 1, ttl: 60, updated_at: Math.floor(Date.now() / 1000),
+        endpoints: [{ type: 'tcp', uri: 'friend:7777', priority: 1, family: 'ipv4' }]
+    };
+    // User A publishes for User B
+    console.log('User A publishing for User B...');
+    await publisher.publish(relays, skA, payloadFriend, { identifier: 'friend-test', recipientPubkey: pkB });
+    // User B resolves User A's record
+    console.log('User B resolving User A...');
+    const friendResult = await resolver.resolve(pkA, skB, 'friend-test');
+    if (friendResult && friendResult.endpoints[0].uri === 'friend:7777') {
+        console.log('Friend-to-Friend resolution successful.');
+    }
+    else {
+        console.error('FAILED: Friend-to-Friend resolution.');
+        process.exit(1);
+    }
+    // Test Group Resolution Utility
+    console.log('Testing NCC05Group utility...');
+    const groupIdentity = NCC05Group.createGroupIdentity();
+    const payloadGroup = {
+        v: 1, ttl: 60, updated_at: Math.floor(Date.now() / 1000),
+        endpoints: [{ type: 'tcp', uri: 'group-service:8888', priority: 1, family: 'ipv4' }]
+    };
+    console.log('Publishing as Group...');
+    await publisher.publish(relays, groupIdentity.sk, payloadGroup, { identifier: 'group-test' });
+    console.log('Resolving as Group Member...');
+    const groupResult = await NCC05Group.resolveAsGroup(resolver, groupIdentity.pk, groupIdentity.sk, 'group-test');
+    if (groupResult && groupResult.endpoints[0].uri === 'group-service:8888') {
+        console.log('NCC05Group resolution successful.');
+    }
+    else {
+        console.error('FAILED: NCC05Group resolution.');
+        process.exit(1);
+    }
+    // Test Group Wrapping (Multi-Recipient)
+    console.log('Testing Group Wrapping (Multi-Recipient)...');
+    const skAlice = generateSecretKey();
+    const pkAlice = getPublicKey(skAlice);
+    const skBob = generateSecretKey();
+    const pkBob = getPublicKey(skBob);
+    const skCharlie = generateSecretKey();
+    const pkCharlie = getPublicKey(skCharlie);
+    const payloadWrap = {
+        v: 1, ttl: 60, updated_at: Math.floor(Date.now() / 1000),
+        endpoints: [{ type: 'tcp', uri: 'multi-recipient:9999', priority: 1, family: 'ipv4' }]
+    };
+    console.log('Alice publishing wrapped record for Bob and Charlie...');
+    await publisher.publishWrapped(relays, skAlice, [pkBob, pkCharlie], payloadWrap, 'wrap-test');
+    console.log('Bob resolving Alice...');
+    const bobResult = await resolver.resolve(pkAlice, skBob, 'wrap-test');
+    console.log('Charlie resolving Alice...');
+    const charlieResult = await resolver.resolve(pkAlice, skCharlie, 'wrap-test');
+    if (bobResult && charlieResult && bobResult.endpoints[0].uri === 'multi-recipient:9999') {
+        console.log('Group Wrapping successful! Both recipients resolved Alice.');
+    }
+    else {
+        console.error('FAILED: Group Wrapping resolution.');
+        process.exit(1);
+    }
     publisher.close(relays);
     resolver.close();
+    relay.stop();
+    console.log('Local Mock Test Suite Passed.');
     process.exit(0);
 }
 test().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ncc-05",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Nostr Community Convention 05 - Identity-Bound Service Locator Resolution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,14 +9,22 @@
     "build": "tsc",
     "prepublishOnly": "npm run build"
   },
-  "keywords": ["nostr", "dns", "identity", "resolution", "privacy"],
+  "keywords": [
+    "nostr",
+    "dns",
+    "identity",
+    "resolution",
+    "privacy"
+  ],
   "author": "lostcause",
   "license": "MIT",
   "dependencies": {
     "nostr-tools": "^2.10.0"
   },
   "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
     "typescript": "^5.0.0",
-    "@types/node": "^20.0.0"
+    "ws": "^8.18.3"
   }
-}
+}

package/src/index.ts

@@ -5,7 +5,8 @@ import {
     finalizeEvent, 
     verifyEvent, 
     Event, 
-    getPublicKey
+    getPublicKey,
+    generateSecretKey
 } from 'nostr-tools';
 
 export interface NCC05Endpoint {
@@ -27,7 +28,42 @@ export interface NCC05Payload {
 export interface ResolverOptions {
     bootstrapRelays?: string[];
     timeout?: number;
-    websocketImplementation?: any; // To support Tor/SOCKS5 proxies in Node.js
+    websocketImplementation?: any;
+}
+
+/**
+ * Advanced multi-recipient "wrapping" structure.
+ */
+export interface WrappedContent {
+    /** The actual payload encrypted with a random symmetric key */
+    ciphertext: string;
+    /** Map of recipient pubkey -> wrapped symmetric key */
+    wraps: Record<string, string>;
+}
+
+export class NCC05Group {
+    static createGroupIdentity() {
+        const sk = generateSecretKey();
+        const pk = getPublicKey(sk);
+        return {
+            nsec: nip19.nsecEncode(sk),
+            sk: sk,
+            pk: pk,
+            npub: nip19.npubEncode(pk)
+        };
+    }
+
+    /**
+     * Resolve a record that was published using a group's shared identity.
+     */
+    static async resolveAsGroup(
+        resolver: NCC05Resolver,
+        groupPubkey: string,
+        groupSecretKey: Uint8Array,
+        identifier: string = 'addr'
+    ): Promise<NCC05Payload | null> {
+        return resolver.resolve(groupPubkey, groupSecretKey, identifier);
+    }
 }
 
 export class NCC05Resolver {
@@ -38,20 +74,16 @@ export class NCC05Resolver {
     constructor(options: ResolverOptions = {}) {
         this.pool = new SimplePool();
         if (options.websocketImplementation) {
-            // @ts-ignore - Patching pool for custom WebSocket (Tor/Proxy)
+            // @ts-ignore
             this.pool.websocketImplementation = options.websocketImplementation;
         }
         this.bootstrapRelays = options.bootstrapRelays || ['wss://relay.damus.io', 'wss://nos.lol'];
         this.timeout = options.timeout || 10000;
     }
 
-    /**
-     * Resolve a locator record for a given pubkey.
-     * Supports both hex and npub strings.
-     */
     async resolve(
         targetPubkey: string, 
-        secretKey: Uint8Array, 
+        secretKey?: Uint8Array, 
         identifier: string = 'addr',
         options: { strict?: boolean, gossip?: boolean } = {}
     ): Promise<NCC05Payload | null> {
@@ -63,20 +95,16 @@ export class NCC05Resolver {
 
         let queryRelays = [...this.bootstrapRelays];
 
-        // 1. NIP-65 Gossip Discovery
         if (options.gossip) {
             const relayListEvent = await this.pool.get(this.bootstrapRelays, {
                 authors: [hexPubkey],
                 kinds: [10002]
             });
-
             if (relayListEvent) {
                 const discoveredRelays = relayListEvent.tags
                     .filter(t => t[0] === 'r')
                     .map(t => t[1]);
-                if (discoveredRelays.length > 0) {
-                    queryRelays = [...new Set([...queryRelays, ...discoveredRelays])];
-                }
+                queryRelays = [...new Set([...queryRelays, ...discoveredRelays])];
             }
         }
 
@@ -88,15 +116,11 @@ export class NCC05Resolver {
         };
 
         const queryPromise = this.pool.querySync(queryRelays, filter);
-        const timeoutPromise = new Promise<null>((resolve) => 
-            setTimeout(() => resolve(null), this.timeout)
-        );
-
+        const timeoutPromise = new Promise<null>((r) => setTimeout(() => r(null), this.timeout));
         const result = await Promise.race([queryPromise, timeoutPromise]);
         
         if (!result || (Array.isArray(result) && result.length === 0)) return null;
         
-        // 2. Filter for valid signatures and sort by created_at
         const validEvents = (result as Event[])
             .filter(e => verifyEvent(e))
             .sort((a, b) => b.created_at - a.created_at);
@@ -104,38 +128,47 @@ export class NCC05Resolver {
         if (validEvents.length === 0) return null;
         const latestEvent = validEvents[0];
 
-        // 2. Decrypt
         try {
-            const conversationKey = nip44.getConversationKey(secretKey, hexPubkey);
-            const decrypted = nip44.decrypt(latestEvent.content, conversationKey);
-            const payload = JSON.parse(decrypted) as NCC05Payload;
-
-            // 3. Basic Validation
-            if (!payload.endpoints || !Array.isArray(payload.endpoints)) {
-                console.error('Invalid NCC-05 payload structure');
-                return null;
+            let content = latestEvent.content;
+            
+            // 1. Try to detect if it's a "Wrapped" multi-recipient event
+            if (content.includes('"wraps"') && secretKey) {
+                const wrapped = JSON.parse(content) as WrappedContent;
+                const myPk = getPublicKey(secretKey);
+                const myWrap = wrapped.wraps[myPk];
+                
+                if (myWrap) {
+                    const conversationKey = nip44.getConversationKey(secretKey, hexPubkey);
+                    const symmetricKeyHex = nip44.decrypt(myWrap, conversationKey);
+                    
+                    // Convert hex symmetric key back to Uint8Array for NIP-44 decryption
+                    const symmetricKey = new Uint8Array(symmetricKeyHex.match(/.{1,2}/g)!.map(byte => parseInt(byte, 16)));
+                    
+                    // The payload was self-encrypted by the publisher with the session key
+                    const sessionConversationKey = nip44.getConversationKey(symmetricKey, getPublicKey(symmetricKey));
+                    content = nip44.decrypt(wrapped.ciphertext, sessionConversationKey);
+                }
+            } else if (secretKey) {
+                const conversationKey = nip44.getConversationKey(secretKey, hexPubkey);
+                content = nip44.decrypt(latestEvent.content, conversationKey);
             }
 
-            // 4. Freshness check
+            const payload = JSON.parse(content) as NCC05Payload;
+            if (!payload.endpoints) return null;
+
             const now = Math.floor(Date.now() / 1000);
             if (now > payload.updated_at + payload.ttl) {
-                if (options.strict) {
-                    console.warn('Rejecting expired NCC-05 record (strict mode)');
-                    return null;
-                }
-                console.warn('NCC-05 record has expired');
+                if (options.strict) return null;
+                console.warn('NCC-05 record expired');
             }
 
             return payload;
         } catch (e) {
-            console.error('Failed to decrypt or parse NCC-05 record:', e);
             return null;
         }
     }
 
-    close() {
-        this.pool.close(this.bootstrapRelays);
-    }
+    close() { this.pool.close(this.bootstrapRelays); }
 }
 
 export class NCC05Publisher {
@@ -144,43 +177,72 @@ export class NCC05Publisher {
     constructor(options: { websocketImplementation?: any } = {}) {
         this.pool = new SimplePool();
         if (options.websocketImplementation) {
-            // @ts-ignore - Patching pool for custom WebSocket (Tor/Proxy)
+            // @ts-ignore
             this.pool.websocketImplementation = options.websocketImplementation;
         }
     }
 
-    /**
-     * Create and publish a locator record.
-     */
-    async publish(
+    async publishWrapped(
         relays: string[],
         secretKey: Uint8Array,
+        recipients: string[],
         payload: NCC05Payload,
         identifier: string = 'addr'
     ): Promise<Event> {
-        const pubkey = getPublicKey(secretKey);
+        const sessionKey = generateSecretKey();
+        const sessionKeyHex = Array.from(sessionKey).map(b => b.toString(16).padStart(2, '0')).join('');
         
-        // 1. Encrypt
-        const conversationKey = nip44.getConversationKey(secretKey, pubkey);
-        const encryptedContent = nip44.encrypt(JSON.stringify(payload), conversationKey);
+        const selfConversation = nip44.getConversationKey(sessionKey, getPublicKey(sessionKey));
+        const ciphertext = nip44.encrypt(JSON.stringify(payload), selfConversation);
+
+        const wraps: Record<string, string> = {};
+        for (const rPk of recipients) {
+            const conversationKey = nip44.getConversationKey(secretKey, rPk);
+            wraps[rPk] = nip44.encrypt(sessionKeyHex, conversationKey);
+        }
+
+        const wrappedContent: WrappedContent = { ciphertext, wraps };
 
-        // 2. Create and Finalize Event
         const eventTemplate = {
             kind: 30058,
             created_at: Math.floor(Date.now() / 1000),
             tags: [['d', identifier]],
-            content: encryptedContent,
+            content: JSON.stringify(wrappedContent),
         };
 
         const signedEvent = finalizeEvent(eventTemplate, secretKey);
-
-        // 3. Publish
         await Promise.all(this.pool.publish(relays, signedEvent));
-        
         return signedEvent;
     }
 
-    close(relays: string[]) {
-        this.pool.close(relays);
+    async publish(
+        relays: string[],
+        secretKey: Uint8Array,
+        payload: NCC05Payload,
+        options: { identifier?: string, recipientPubkey?: string, public?: boolean } = {}
+    ): Promise<Event> {
+        const myPubkey = getPublicKey(secretKey);
+        const identifier = options.identifier || 'addr';
+        let content = JSON.stringify(payload);
+
+        if (!options.public) {
+            const encryptionTarget = options.recipientPubkey || myPubkey;
+            const conversationKey = nip44.getConversationKey(secretKey, encryptionTarget);
+            content = nip44.encrypt(content, conversationKey);
+        }
+
+        const eventTemplate = {
+            kind: 30058,
+            created_at: Math.floor(Date.now() / 1000),
+            pubkey: myPubkey,
+            tags: [['d', identifier]],
+            content: content,
+        };
+
+        const signedEvent = finalizeEvent(eventTemplate, secretKey);
+        await Promise.all(this.pool.publish(relays, signedEvent));
+        return signedEvent;
     }
-}
+
+    close(relays: string[]) { this.pool.close(relays); }
+}

package/src/mock-relay.ts

@@ -0,0 +1,51 @@
+import { WebSocketServer, WebSocket } from 'ws';
+
+export class MockRelay {
+    private wss: WebSocketServer;
+    private events: any[] = [];
+
+    constructor(port: number = 8080) {
+        this.wss = new WebSocketServer({ port });
+        this.wss.on('connection', (ws: WebSocket) => {
+            ws.on('message', (data: string) => {
+                const msg = JSON.parse(data);
+                const type = msg[0];
+
+                if (type === 'EVENT') {
+                    const event = msg[1];
+                    // Basic replaceable logic for test consistency
+                    if (event.kind === 30058 || event.kind === 10002) {
+                        const dTag = event.tags.find((t: any) => t[0] === 'd')?.[1] || "";
+                        this.events = this.events.filter(e => 
+                            !(e.pubkey === event.pubkey && e.kind === event.kind && (e.tags.find((t: any) => t[0] === 'd')?.[1] || "") === dTag)
+                        );
+                    }
+                    this.events.push(event);
+                    ws.send(JSON.stringify(["OK", event.id, true, ""]));
+                } else if (type === 'REQ') {
+                    const subId = msg[1];
+                    const filters = msg[2];
+                    
+                    this.events.forEach(event => {
+                        let match = true;
+                        if (filters.authors && !filters.authors.includes(event.pubkey)) match = false;
+                        if (filters.kinds && !filters.kinds.includes(event.kind)) match = false;
+                        if (filters['#d']) {
+                            const dTag = event.tags.find((t: any) => t[0] === 'd')?.[1];
+                            if (!filters['#d'].includes(dTag)) match = false;
+                        }
+                        
+                        if (match) {
+                            ws.send(JSON.stringify(["EVENT", subId, event]));
+                        }
+                    });
+                    ws.send(JSON.stringify(["EOSE", subId]));
+                }
+            });
+        });
+    }
+
+    stop() {
+        this.wss.close();
+    }
+}

package/src/test.ts

@@ -1,10 +1,14 @@
-import { NCC05Publisher, NCC05Resolver, NCC05Payload } from './index.js';
-import { generateSecretKey, getPublicKey } from 'nostr-tools';
+import { NCC05Publisher, NCC05Resolver, NCC05Payload, NCC05Group } from './index.js';
+import { generateSecretKey, getPublicKey, nip19 } from 'nostr-tools';
+import { MockRelay } from './mock-relay.js';
 
 async function test() {
+    console.log('Starting Mock Relay...');
+    const relay = new MockRelay(8080);
+    const relays = ['ws://localhost:8080'];
+
     const sk = generateSecretKey();
     const pk = getPublicKey(sk);
-    const relays = ['wss://relay.damus.io'];
 
     const publisher = new NCC05Publisher();
     const resolver = new NCC05Resolver({ bootstrapRelays: relays });
@@ -28,7 +32,8 @@ async function test() {
     if (resolved) {
         console.log('Successfully resolved:', JSON.stringify(resolved, null, 2));
     } else {
-        console.log('Failed to resolve.');
+        console.error('FAILED: resolution.');
+        process.exit(1);
     }
 
     // Test Strict Mode with Expired Record
@@ -39,7 +44,7 @@ async function test() {
         updated_at: Math.floor(Date.now() / 1000) - 10, // 10s ago
         endpoints: [{ type: 'tcp', uri: '1.1.1.1:1', priority: 1, family: 'ipv4' }]
     };
-    await publisher.publish(relays, sk, expiredPayload, 'expired-test');
+    await publisher.publish(relays, sk, expiredPayload, { identifier: 'expired-test' });
     const strictResult = await resolver.resolve(pk, sk, 'expired-test', { strict: true });
     
     if (strictResult === null) {
@@ -51,8 +56,6 @@ async function test() {
 
     // Test Gossip Mode
     console.log('Testing Gossip discovery...');
-    // In this test, we just point kind:10002 to the same relay we are using
-    // to verify the code path executes.
     const relayListTemplate = {
         kind: 10002,
         created_at: Math.floor(Date.now() / 1000),
@@ -60,6 +63,7 @@ async function test() {
         content: '',
     };
     const signedRL = (await import('nostr-tools')).finalizeEvent(relayListTemplate, sk);
+    // @ts-ignore
     await Promise.all(publisher['pool'].publish(relays, signedRL));
     
     const gossipResult = await resolver.resolve(pk, sk, 'addr', { gossip: true });
@@ -72,7 +76,7 @@ async function test() {
 
     // Test npub resolution
     console.log('Testing npub resolution...');
-    const npub = (await import('nostr-tools')).nip19.npubEncode(pk);
+    const npub = nip19.npubEncode(pk);
     const npubResult = await resolver.resolve(npub, sk);
     if (npubResult) {
         console.log('npub resolution successful.');
@@ -81,8 +85,86 @@ async function test() {
         process.exit(1);
     }
 
+    // Test Friend-to-Friend resolution
+    console.log('Testing Friend-to-Friend resolution...');
+    const skA = generateSecretKey();
+    const pkA = getPublicKey(skA);
+    const skB = generateSecretKey();
+    const pkB = getPublicKey(skB);
+
+    const payloadFriend: NCC05Payload = {
+        v: 1, ttl: 60, updated_at: Math.floor(Date.now() / 1000),
+        endpoints: [{ type: 'tcp', uri: 'friend:7777', priority: 1, family: 'ipv4' }]
+    };
+
+    // User A publishes for User B
+    console.log('User A publishing for User B...');
+    await publisher.publish(relays, skA, payloadFriend, { identifier: 'friend-test', recipientPubkey: pkB });
+
+    // User B resolves User A's record
+    console.log('User B resolving User A...');
+    const friendResult = await resolver.resolve(pkA, skB, 'friend-test');
+    if (friendResult && friendResult.endpoints[0].uri === 'friend:7777') {
+        console.log('Friend-to-Friend resolution successful.');
+    } else {
+        console.error('FAILED: Friend-to-Friend resolution.');
+        process.exit(1);
+    }
+
+    // Test Group Resolution Utility
+    console.log('Testing NCC05Group utility...');
+    const groupIdentity = NCC05Group.createGroupIdentity();
+    const payloadGroup: NCC05Payload = {
+        v: 1, ttl: 60, updated_at: Math.floor(Date.now() / 1000),
+        endpoints: [{ type: 'tcp', uri: 'group-service:8888', priority: 1, family: 'ipv4' }]
+    };
+
+    console.log('Publishing as Group...');
+    await publisher.publish(relays, groupIdentity.sk, payloadGroup, { identifier: 'group-test' });
+
+    console.log('Resolving as Group Member...');
+    const groupResult = await NCC05Group.resolveAsGroup(resolver, groupIdentity.pk, groupIdentity.sk, 'group-test');
+    if (groupResult && groupResult.endpoints[0].uri === 'group-service:8888') {
+        console.log('NCC05Group resolution successful.');
+    } else {
+        console.error('FAILED: NCC05Group resolution.');
+        process.exit(1);
+    }
+
+    // Test Group Wrapping (Multi-Recipient)
+    console.log('Testing Group Wrapping (Multi-Recipient)...');
+    const skAlice = generateSecretKey();
+    const pkAlice = getPublicKey(skAlice);
+    const skBob = generateSecretKey();
+    const pkBob = getPublicKey(skBob);
+    const skCharlie = generateSecretKey();
+    const pkCharlie = getPublicKey(skCharlie);
+
+    const payloadWrap: NCC05Payload = {
+        v: 1, ttl: 60, updated_at: Math.floor(Date.now() / 1000),
+        endpoints: [{ type: 'tcp', uri: 'multi-recipient:9999', priority: 1, family: 'ipv4' }]
+    };
+
+    console.log('Alice publishing wrapped record for Bob and Charlie...');
+    await publisher.publishWrapped(relays, skAlice, [pkBob, pkCharlie], payloadWrap, 'wrap-test');
+
+    console.log('Bob resolving Alice...');
+    const bobResult = await resolver.resolve(pkAlice, skBob, 'wrap-test');
+    
+    console.log('Charlie resolving Alice...');
+    const charlieResult = await resolver.resolve(pkAlice, skCharlie, 'wrap-test');
+
+    if (bobResult && charlieResult && bobResult.endpoints[0].uri === 'multi-recipient:9999') {
+        console.log('Group Wrapping successful! Both recipients resolved Alice.');
+    } else {
+        console.error('FAILED: Group Wrapping resolution.');
+        process.exit(1);
+    }
+
     publisher.close(relays);
     resolver.close();
+    relay.stop();
+    console.log('Local Mock Test Suite Passed.');
     process.exit(0);
 }