nostr-double-ratchet 0.0.27 → 0.0.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-double-ratchet",
-  "version": "0.0.27",
+  "version": "0.0.29",
   "type": "module",
   "packageManager": "yarn@1.22.22",
   "description": "Nostr double ratchet library",
@@ -14,7 +14,8 @@
     "build": "vite build && tsc",
     "examples": "cd examples && vite build && tsc",
     "examples-dev": "cd examples && vite && tsc",
-    "docs": "typedoc --out docs src/index.ts"
+    "docs": "typedoc --out docs src/index.ts",
+    "lint": "eslint src --ext .ts --fix"
   },
   "repository": {
     "type": "git",
@@ -32,25 +33,26 @@
     "dist"
   ],
   "devDependencies": {
-    "@nostr-dev-kit/ndk": "2.11.2",
-    "@types/lodash": "^4.17.15",
-    "@types/node": "^22.13.4",
-    "@typescript-eslint/eslint-plugin": "^8.24.1",
-    "@typescript-eslint/parser": "^8.24.1",
-    "eslint": "^9.20.1",
-    "eslint-config-prettier": "^10.0.1",
-    "eslint-plugin-prettier": "^5.2.3",
+    "@nostr-dev-kit/ndk": "2.14.23",
+    "@types/lodash": "^4.17.17",
+    "@types/node": "^22.15.21",
+    "@typescript-eslint/eslint-plugin": "^8.33.1",
+    "@typescript-eslint/parser": "^8.33.1",
+    "eslint": "^9.28.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-prettier": "^5.4.0",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "lodash": "^4.17.21",
-    "tsx": "^4.19.2",
-    "typedoc": "^0.27.7",
-    "typescript": "^5.7.3",
+    "tsx": "^4.19.4",
+    "typedoc": "^0.28.4",
+    "typescript": "^5.8.3",
     "typescript-lru-cache": "^2.0.0",
-    "vite": "^6.1.0",
-    "vitest": "^3.0.6",
-    "ws": "^8.18.0"
+    "vite": "^6.3.5",
+    "vitest": "^3.1.4",
+    "ws": "^8.18.2"
   },
   "dependencies": {
-    "nostr-tools": "^2.10.4"
+    "nostr-tools": "^2.15.0",
+    "react-blurhash": "^0.3.0"
   }
 }

package/src/Invite.ts

@@ -25,12 +25,13 @@ export class Invite {
         public sharedSecret: string,
         public inviter: string,
         public inviterEphemeralPrivateKey?: Uint8Array,
-        public label?: string,
+        public deviceId?: string,
         public maxUses?: number,
         public usedBy: string[] = [],
-    ) {}
+    ) {
+    }
 
-    static createNew(inviter: string, label?: string, maxUses?: number): Invite {
+    static createNew(inviter: string, deviceId?: string, maxUses?: number): Invite {
         if (!inviter) {
             throw new Error("Inviter public key is required");
         }
@@ -42,7 +43,7 @@ export class Invite {
             sharedSecret,
             inviter,
             inviterEphemeralPrivateKey,
-            label,
+            deviceId,
             maxUses
         );
     }
@@ -55,7 +56,7 @@ export class Invite {
         }
 
         const decodedHash = decodeURIComponent(rawHash);
-        let data: any;
+        let data: { inviter?: string; ephemeralKey?: string; sharedSecret?: string };
         try {
             data = JSON.parse(decodedHash);
         } catch (err) {
@@ -81,7 +82,7 @@ export class Invite {
             data.sharedSecret,
             data.inviter,
             data.inviterEphemeralPrivateKey ? new Uint8Array(data.inviterEphemeralPrivateKey) : undefined,
-            data.label,
+            data.deviceId,
             data.maxUses,
             data.usedBy
         );
@@ -104,6 +105,10 @@ export class Invite {
         const sharedSecret = tags.find(([key]) => key === 'sharedSecret')?.[1];
         const inviter = event.pubkey;
 
+        // Extract deviceId from the "d" tag (format: double-ratchet/invites/<deviceId>)
+        const deviceTag = tags.find(([key]) => key === 'd')?.[1]
+        const deviceId = deviceTag?.split('/')?.[2]
+
         if (!inviterEphemeralPublicKey || !sharedSecret) {
             throw new Error("Invalid invite event: missing session key or sharedSecret");
         }
@@ -111,28 +116,26 @@ export class Invite {
         return new Invite(
             inviterEphemeralPublicKey,
             sharedSecret,
-            inviter
+            inviter,
+            undefined, // inviterEphemeralPrivateKey not available when parsing from event
+            deviceId
         );
     }
 
-    static fromUser(user: string, subscribe: NostrSubscribe, onInvite: (invite: Invite) => void): Unsubscribe {
+    static fromUser(user: string, subscribe: NostrSubscribe, onInvite: (_invite: Invite) => void): Unsubscribe {
         const filter: Filter = {
             kinds: [INVITE_EVENT_KIND],
             authors: [user],
-            limit: 1,
-            "#d": ["double-ratchet/invites/public"],
+            "#l": ["double-ratchet/invites"]
         };
-        let latest = 0;
+        const seenIds = new Set<string>()
         const unsub = subscribe(filter, (event) => {
-            if (!event.created_at || event.created_at <= latest) {
-                return;
-            }
-            latest = event.created_at;
+            if (seenIds.has(event.id)) return
+            seenIds.add(event.id)
             try {
                 const inviteLink = Invite.fromEvent(event);
                 onInvite(inviteLink);
-            } catch (error) {
-                console.error("Error processing invite:", error, "event:", event);
+            } catch {
             }
         });
 
@@ -148,7 +151,7 @@ export class Invite {
             sharedSecret: this.sharedSecret,
             inviter: this.inviter,
             inviterEphemeralPrivateKey: this.inviterEphemeralPrivateKey ? Array.from(this.inviterEphemeralPrivateKey) : undefined,
-            label: this.label,
+            deviceId: this.deviceId,
             maxUses: this.maxUses,
             usedBy: this.usedBy,
         });
@@ -169,6 +172,9 @@ export class Invite {
     }
 
     getEvent(): UnsignedEvent {
+        if (!this.deviceId) {
+            throw new Error("Device ID is required");
+        }
         return {
             kind: INVITE_EVENT_KIND,
             pubkey: this.inviter,
@@ -177,7 +183,7 @@ export class Invite {
             tags: [
                 ['ephemeralKey', this.inviterEphemeralPublicKey],
                 ['sharedSecret', this.sharedSecret],
-                ['d', 'double-ratchet/invites/public'],
+                ['d', 'double-ratchet/invites/' + this.deviceId],
                 ['l', 'double-ratchet/invites']
             ],
         };
@@ -185,11 +191,12 @@ export class Invite {
 
     /**
      * Called by the invitee. Accepts the invite and creates a new session with the inviter.
-     * 
-     * @param inviteeSecretKey - The invitee's secret key or a signing function
+     *
      * @param nostrSubscribe - A function to subscribe to Nostr events
+     * @param inviteePublicKey - The invitee's public key
+     * @param encryptor - The invitee's secret key or a signing/encrypt function
      * @returns An object containing the new session and an event to be published
-     * 
+     *
      * 1. Inner event: No signature, content encrypted with DH(inviter, invitee).
      *    Purpose: Authenticate invitee. Contains invitee session key.
      * 2. Envelope: No signature, content encrypted with DH(inviter, random key).
@@ -240,7 +247,7 @@ export class Invite {
         return { session, event: finalizeEvent(envelope, randomSenderKey) };
     }
 
-    listen(decryptor: Uint8Array | DecryptFunction, nostrSubscribe: NostrSubscribe, onSession: (session: Session, identity?: string) => void): Unsubscribe {
+    listen(decryptor: Uint8Array | DecryptFunction, nostrSubscribe: NostrSubscribe, onSession: (_session: Session, _identity?: string) => void): Unsubscribe {
         if (!this.inviterEphemeralPrivateKey) {
             throw new Error("Inviter session key is not available");
         }
@@ -253,7 +260,6 @@ export class Invite {
         return nostrSubscribe(filter, async (event) => {
             try {
                 if (this.maxUses && this.usedBy.length >= this.maxUses) {
-                    console.error("Invite has reached maximum number of uses");
                     return;
                 }
 
@@ -279,9 +285,8 @@ export class Invite {
                 const session = Session.init(nostrSubscribe, inviteeSessionPublicKey, this.inviterEphemeralPrivateKey!, false, sharedSecret, name);
 
                 onSession(session, inviteeIdentity);
-            } catch (error) {
-                console.error("Error processing invite message:", error, "event", event);
+            } catch {
             }
         });
     }
-}
+}

package/src/Session.ts

@@ -1,5 +1,5 @@
 import { generateSecretKey, getPublicKey, nip44, finalizeEvent, VerifiedEvent, UnsignedEvent, getEventHash, validateEvent } from "nostr-tools";
-import { bytesToHex } from "@noble/hashes/utils";
+
 import {
   SessionState,
   Header,
@@ -38,9 +38,9 @@ export class Session {
 
   /**
    * Initializes a new secure communication session
-   * @param nostrSubscribe Function to subscribe to Nostr events
-   * @param theirNextNostrPublicKey The public key of the other party
-   * @param ourCurrentPrivateKey Our current private key for Nostr
+   * @param nostrSubscribe Function to subscribe to Nostr events. Make sure it deduplicates events (doesn't return the same event twice), otherwise you'll see decryption errors!
+   * @param theirEphemeralNostrPublicKey The ephemeral public key of the other party for the initial handshake
+   * @param ourEphemeralNostrPrivateKey Our ephemeral private key for the initial handshake
    * @param isInitiator Whether we are initiating the conversation (true) or responding (false)
    * @param sharedSecret Initial shared secret for securing the first message chain
    * @param name Optional name for the session (for debugging)
@@ -205,17 +205,7 @@ export class Session {
     this.state.receivingChainKey = newReceivingChainKey;
     this.state.receivingChainMessageNumber++;
 
-    try {
-      return nip44.decrypt(ciphertext, messageKey);
-    } catch (error) {
-      console.error(this.name, 'Decryption failed:', error, {
-        messageKey: bytesToHex(messageKey).slice(0, 4),
-        receivingChainKey: bytesToHex(this.state.receivingChainKey).slice(0, 4),
-        sendingChainKey: this.state.sendingChainKey && bytesToHex(this.state.sendingChainKey).slice(0, 4),
-        rootKey: bytesToHex(this.state.rootKey).slice(0, 4)
-      });
-      throw error;
-    }
+    return nip44.decrypt(ciphertext, messageKey);
   }
 
   private ratchetStep() {
@@ -294,14 +284,14 @@ export class Session {
   }
 
   // 4. NOSTR EVENT HANDLING
-  private decryptHeader(event: any): [Header, boolean, boolean] {
+  private decryptHeader(event: { tags: string[][]; pubkey: string }): [Header, boolean, boolean] {
     const encryptedHeader = event.tags[0][1];
     if (this.state.ourCurrentNostrKey) {
       const currentSecret = nip44.getConversationKey(this.state.ourCurrentNostrKey.privateKey, event.pubkey);
       try {
         const header = JSON.parse(nip44.decrypt(encryptedHeader, currentSecret)) as Header;
         return [header, false, false];
-      } catch (error) {
+      } catch {
         // Decryption with currentSecret failed, try with nextSecret
       }
     }
@@ -310,7 +300,7 @@ export class Session {
     try {
       const header = JSON.parse(nip44.decrypt(encryptedHeader, nextSecret)) as Header;
       return [header, true, false];
-    } catch (error) {
+    } catch {
       // Decryption with nextSecret also failed
     }
 
@@ -320,7 +310,7 @@ export class Session {
         try {
           const header = JSON.parse(nip44.decrypt(encryptedHeader, key)) as Header;
           return [header, false, true];
-        } catch (error) {
+        } catch {
           // Decryption failed, try next secret
         }
       }
@@ -329,7 +319,7 @@ export class Session {
     throw new Error("Failed to decrypt header with current and skipped header keys");
   }
 
-  private handleNostrEvent(e: any) {
+  private handleNostrEvent(e: { tags: string[][]; pubkey: string; content: string }) {
     const [header, shouldRatchet, isSkipped] = this.decryptHeader(e);
 
     if (!isSkipped) {
@@ -358,16 +348,14 @@ export class Session {
     const text = this.ratchetDecrypt(header, e.content, e.pubkey);
     const innerEvent = JSON.parse(text);
     if (!validateEvent(innerEvent)) {
-      console.error("Invalid event received", innerEvent);
       return;
     }
 
     if (innerEvent.id !== getEventHash(innerEvent)) {
-      console.error("Event hash does not match", innerEvent);
       return;
     }
 
-    this.internalSubscriptions.forEach(callback => callback(innerEvent, e));  
+    this.internalSubscriptions.forEach(callback => callback(innerEvent, e as VerifiedEvent));  
   }
 
   private subscribeToNostrEvents() {

package/src/SessionManager.ts

@@ -0,0 +1,328 @@
+import { CHAT_MESSAGE_KIND, NostrPublish, NostrSubscribe, Rumor, Unsubscribe } from "./types"
+import { UserRecord } from "./UserRecord"
+import { Invite } from "./Invite"
+import { getPublicKey } from "nostr-tools"
+import { StorageAdapter, InMemoryStorageAdapter } from "./StorageAdapter"
+import { serializeSessionState, deserializeSessionState } from "./utils"
+import { Session } from "./Session"
+
+export default class SessionManager {
+    private userRecords: Map<string, UserRecord> = new Map()
+    private nostrSubscribe: NostrSubscribe
+    private nostrPublish: NostrPublish
+    private ourIdentityKey: Uint8Array
+    private inviteUnsubscribes: Map<string, Unsubscribe> = new Map()
+    private deviceId: string
+    private invite?: Invite
+    private storage: StorageAdapter
+
+    constructor(
+        ourIdentityKey: Uint8Array,
+        deviceId: string,
+        nostrSubscribe: NostrSubscribe,
+        nostrPublish: NostrPublish,
+        storage: StorageAdapter = new InMemoryStorageAdapter(),
+    ) {
+        this.userRecords = new Map()
+        this.nostrSubscribe = nostrSubscribe
+        this.nostrPublish = nostrPublish
+        this.ourIdentityKey = ourIdentityKey
+        this.deviceId = deviceId
+        this.storage = storage
+
+        // Kick off initialisation in background for backwards compatibility
+        // Users that need to wait can call await manager.init()
+        this.init()
+    }
+
+    private _initialised = false
+
+    /**
+     * Perform asynchronous initialisation steps: create (or load) our invite,
+     * publish it, hydrate sessions from storage and subscribe to new invites.
+     * Can be awaited by callers that need deterministic readiness.
+     */
+    public async init(): Promise<void> {
+        if (this._initialised) return
+
+        const ourPublicKey = getPublicKey(this.ourIdentityKey)
+
+        // 1. Hydrate existing sessions (placeholder for future implementation)
+        await this.loadSessions()
+
+        // 2. Create or load our own invite
+        let invite: Invite | undefined
+        try {
+            const stored = await this.storage.get<string>(`invite/${this.deviceId}`)
+            if (stored) {
+                invite = Invite.deserialize(stored)
+            }
+        } catch {/* ignore malformed */}
+
+        if (!invite) {
+            invite = Invite.createNew(ourPublicKey, this.deviceId)
+            await this.storage.put(`invite/${this.deviceId}`, invite.serialize()).catch(() => {})
+        }
+        this.invite = invite
+
+        // 2b. Listen for acceptances of *our* invite and create sessions
+        this.invite.listen(
+            this.ourIdentityKey,
+            this.nostrSubscribe,
+            (session, inviteePubkey) => {
+                if (!inviteePubkey) return
+                try {
+                    let userRecord = this.userRecords.get(inviteePubkey)
+                    if (!userRecord) {
+                        userRecord = new UserRecord(inviteePubkey, this.nostrSubscribe)
+                        this.userRecords.set(inviteePubkey, userRecord)
+                    }
+
+                    const deviceKey = session.name || 'unknown'
+                    userRecord.upsertSession(deviceKey, session)
+                    this.saveSession(inviteePubkey, deviceKey, session)
+
+                    session.onEvent((_event: Rumor) => {
+                        this.internalSubscriptions.forEach(cb => cb(_event))
+                    })
+                } catch {/* ignore errors */}
+            }
+        )
+
+        // 3. Subscribe to our own invites from other devices
+        Invite.fromUser(ourPublicKey, this.nostrSubscribe, async (invite) => {
+            try {
+                const inviteDeviceId = invite['deviceId'] || 'unknown'
+                if (!inviteDeviceId || inviteDeviceId === this.deviceId) {
+                    return
+                }
+
+                const existingRecord = this.userRecords.get(ourPublicKey)
+                if (existingRecord?.getActiveSessions().some(session => session.name === inviteDeviceId)) {
+                    return
+                }
+
+                const { session, event } = await invite.accept(
+                    this.nostrSubscribe,
+                    ourPublicKey,
+                    this.ourIdentityKey
+                )
+                this.nostrPublish(event)?.catch(() => {})
+
+                this.saveSession(ourPublicKey, inviteDeviceId, session)
+
+                let userRecord = this.userRecords.get(ourPublicKey)
+                if (!userRecord) {
+                    userRecord = new UserRecord(ourPublicKey, this.nostrSubscribe)
+                    this.userRecords.set(ourPublicKey, userRecord)
+                }
+                const deviceId = invite['deviceId'] || event.id || 'unknown'
+                userRecord.upsertSession(deviceId, session)
+                this.saveSession(ourPublicKey, deviceId, session)
+
+                session.onEvent((_event: Rumor) => {
+                    this.internalSubscriptions.forEach(cb => cb(_event))
+                })
+            } catch (err) {
+                // eslint-disable-next-line no-console
+                console.error('Own-invite accept failed', err)
+            }
+        })
+
+        this._initialised = true
+        await this.nostrPublish(this.invite.getEvent()).catch(() => {})
+    }
+
+    private async loadSessions() {
+        const base = 'session/'
+        const keys = await this.storage.list(base)
+        for (const key of keys) {
+            const rest = key.substring(base.length)
+            const idx = rest.indexOf('/')
+            if (idx === -1) continue
+            const ownerPubKey = rest.substring(0, idx)
+            const deviceId = rest.substring(idx + 1) || 'unknown'
+
+            const data = await this.storage.get<string>(key)
+            if (!data) continue
+            try {
+                const state = deserializeSessionState(data)
+                const session = new Session(this.nostrSubscribe, state)
+
+                let userRecord = this.userRecords.get(ownerPubKey)
+                if (!userRecord) {
+                    userRecord = new UserRecord(ownerPubKey, this.nostrSubscribe)
+                    this.userRecords.set(ownerPubKey, userRecord)
+                }
+                userRecord.upsertSession(deviceId, session)
+                this.saveSession(ownerPubKey, deviceId, session)
+
+                session.onEvent((_event: Rumor) => {
+                    this.internalSubscriptions.forEach(cb => cb(_event))
+                })
+            } catch {
+                // corrupted entry — ignore
+            }
+        }
+    }
+
+    private async saveSession(ownerPubKey: string, deviceId: string, session: Session) {
+        try {
+            const key = `session/${ownerPubKey}/${deviceId}`
+            await this.storage.put(key, serializeSessionState(session.state))
+        } catch {/* ignore */}
+    }
+
+    getDeviceId(): string {
+        return this.deviceId
+    }
+
+    getInvite(): Invite {
+        if (!this.invite) {
+            throw new Error("SessionManager not initialised yet")
+        }
+        return this.invite
+    }
+
+    async sendText(recipientIdentityKey: string, text: string) {
+        const event = {
+            kind: CHAT_MESSAGE_KIND,
+            content: text,
+        }
+        return await this.sendEvent(recipientIdentityKey, event)
+    }
+
+    async sendEvent(recipientIdentityKey: string, event: Partial<Rumor>) {
+        const results = []
+        
+        // Send to recipient's devices
+        const userRecord = this.userRecords.get(recipientIdentityKey)
+        if (!userRecord) {
+            // Listen for invites from recipient and return without throwing; caller
+            // can await a subsequent session establishment.
+            this.listenToUser(recipientIdentityKey)
+            return []
+        }
+
+        // Send to all active sessions with recipient
+        for (const session of userRecord.getActiveSessions()) {
+            const { event: encryptedEvent } = session.sendEvent(event)
+            results.push(encryptedEvent)
+        }
+
+        // Send to our own devices (for multi-device sync)
+        const ourPublicKey = getPublicKey(this.ourIdentityKey)
+        const ownUserRecord = this.userRecords.get(ourPublicKey)
+        if (ownUserRecord) {
+            for (const session of ownUserRecord.getActiveSessions()) {
+                const { event: encryptedEvent } = session.sendEvent(event)
+                results.push(encryptedEvent)
+            }
+        }
+
+        return results
+    }
+
+    listenToUser(userPubkey: string) {
+        // Don't subscribe multiple times to the same user
+        if (this.inviteUnsubscribes.has(userPubkey)) return
+
+        const unsubscribe = Invite.fromUser(userPubkey, this.nostrSubscribe, async (_invite) => {
+            try {
+                const { session, event } = await _invite.accept(
+                    this.nostrSubscribe,
+                    getPublicKey(this.ourIdentityKey),
+                    this.ourIdentityKey
+                )
+                this.nostrPublish(event)?.catch(() => {})
+
+                // Store the new session
+                let userRecord = this.userRecords.get(userPubkey)
+                if (!userRecord) {
+                    userRecord = new UserRecord(userPubkey, this.nostrSubscribe)
+                    this.userRecords.set(userPubkey, userRecord)
+                }
+                const deviceId = (_invite instanceof Invite && _invite.deviceId) ? _invite.deviceId : event.id || 'unknown'
+                this.saveSession(userPubkey, deviceId, session)
+
+                // Set up event handling for the new session
+                session.onEvent((_event: Rumor) => {
+                    this.internalSubscriptions.forEach(callback => callback(_event))
+                })
+
+                // Return the event to be published
+                return event
+            } catch {
+            }
+        })
+
+        this.inviteUnsubscribes.set(userPubkey, unsubscribe)
+    }
+
+    stopListeningToUser(userPubkey: string) {
+        const unsubscribe = this.inviteUnsubscribes.get(userPubkey)
+        if (unsubscribe) {
+            unsubscribe()
+            this.inviteUnsubscribes.delete(userPubkey)
+        }
+    }
+
+    // Update onEvent to include internalSubscriptions management
+    private internalSubscriptions: Set<(event: Rumor) => void> = new Set()
+
+    onEvent(callback: (event: Rumor) => void) {
+        this.internalSubscriptions.add(callback)
+
+        // Subscribe to existing sessions
+        for (const userRecord of this.userRecords.values()) {
+            for (const session of userRecord.getActiveSessions()) {
+                session.onEvent((_event: Rumor) => {
+                    callback(_event)
+                })
+            }
+        }
+
+        // Return unsubscribe function
+        return () => {
+            this.internalSubscriptions.delete(callback)
+        }
+    }
+
+    close() {
+        // Clean up all subscriptions
+        for (const unsubscribe of this.inviteUnsubscribes.values()) {
+            unsubscribe()
+        }
+        this.inviteUnsubscribes.clear()
+        
+        // Close all sessions
+        for (const userRecord of this.userRecords.values()) {
+            for (const session of userRecord.getActiveSessions()) {
+                session.close()
+            }
+        }
+        this.userRecords.clear()
+        this.internalSubscriptions.clear()
+    }
+
+    /**
+     * Accept an invite as our own device, persist the session, and publish the acceptance event.
+     * Used for multi-device flows where a user adds a new device.
+     */
+    public async acceptOwnInvite(invite: Invite) {
+        const ourPublicKey = getPublicKey(this.ourIdentityKey);
+        const { session, event } = await invite.accept(
+            this.nostrSubscribe,
+            ourPublicKey,
+            this.ourIdentityKey
+        );
+        let userRecord = this.userRecords.get(ourPublicKey);
+        if (!userRecord) {
+            userRecord = new UserRecord(ourPublicKey, this.nostrSubscribe);
+            this.userRecords.set(ourPublicKey, userRecord);
+        }
+        userRecord.upsertSession(session.name || 'unknown', session);
+        await this.saveSession(ourPublicKey, session.name || 'unknown', session);
+        this.nostrPublish(event)?.catch(() => {});
+    }
+}