nostr-double-ratchet 0.0.5 → 0.0.7

package/src/Channel.ts

@@ -62,6 +62,7 @@ export class Channel {
       receivingChainMessageNumber: 0,
       previousSendingChainMessageCount: 0,
       skippedMessageKeys: {},
+      skippedHeaderKeys: {},
     };
     const channel = new Channel(nostrSubscribe, state);
     if (name) channel.name = name;
@@ -106,6 +107,14 @@ export class Channel {
     return () => this.internalSubscriptions.delete(id)
   }
 
+  /**
+   * Stop listening to incoming messages
+   */
+  close() {
+    this.nostrUnsubscribe?.();
+    this.nostrNextUnsubscribe?.();
+  }
+
   // 2. RATCHET FUNCTIONS
   private ratchetEncrypt(plaintext: string): [Header, string] {
     const [newSendingChainKey, messageKey] = kdf(this.state.sendingChainKey!, new Uint8Array([1]), 2);
@@ -176,6 +185,18 @@ export class Channel {
       this.state.receivingChainKey = newReceivingChainKey;
       const key = skippedMessageIndexKey(nostrSender, this.state.receivingChainMessageNumber);
       this.state.skippedMessageKeys[key] = messageKey;
+      
+      if (!this.state.skippedHeaderKeys[nostrSender]) {
+        const secrets: Uint8Array[] = [];
+        if (this.state.ourCurrentNostrKey) {
+          const currentSecret = nip44.getConversationKey(this.state.ourCurrentNostrKey.privateKey, nostrSender);
+          secrets.push(currentSecret);
+        }
+        const nextSecret = nip44.getConversationKey(this.state.ourNextNostrKey.privateKey, nostrSender);
+        secrets.push(nextSecret);
+        this.state.skippedHeaderKeys[nostrSender] = secrets;
+      }
+      
       this.state.receivingChainMessageNumber++;
     }
   }
@@ -185,19 +206,29 @@ export class Channel {
     if (key in this.state.skippedMessageKeys) {
       const mk = this.state.skippedMessageKeys[key];
       delete this.state.skippedMessageKeys[key];
+      
+      // Check if we have any remaining skipped messages from this sender
+      const hasMoreSkippedMessages = Object.keys(this.state.skippedMessageKeys).some(k => k.startsWith(`${nostrSender}:`));
+      if (!hasMoreSkippedMessages) {
+        // Clean up header keys and unsubscribe as no more skipped messages from this sender
+        delete this.state.skippedHeaderKeys[nostrSender];
+        this.nostrUnsubscribe?.();
+        this.nostrUnsubscribe = undefined;
+      }
+      
       return nip44.decrypt(ciphertext, mk);
     }
     return null;
   }
 
   // 4. NOSTR EVENT HANDLING
-  private decryptHeader(event: any): [Header, boolean] {
+  private decryptHeader(event: any): [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];
+        return [header, false, false];
       } catch (error) {
         // Decryption with currentSecret failed, try with nextSecret
       }
@@ -206,30 +237,49 @@ export class Channel {
     const nextSecret = nip44.getConversationKey(this.state.ourNextNostrKey.privateKey, event.pubkey);
     try {
       const header = JSON.parse(nip44.decrypt(encryptedHeader, nextSecret)) as Header;
-      return [header, true];
+      return [header, true, false];
     } catch (error) {
       // Decryption with nextSecret also failed
     }
 
-    throw new Error("Failed to decrypt header with both current and next secrets");
+    const keys = this.state.skippedHeaderKeys[event.pubkey];
+    if (keys) {
+      for (const key of keys) {
+        try {
+          const header = JSON.parse(nip44.decrypt(encryptedHeader, key)) as Header;
+          return [header, false, true];
+        } catch (error) {
+          // Decryption failed, try next secret
+        }
+      }
+    }
+
+    throw new Error("Failed to decrypt header with current and skipped header keys");
   }
 
   private handleNostrEvent(e: any) {
-    const [header, shouldRatchet] = this.decryptHeader(e);
+    const [header, shouldRatchet, isSkipped] = this.decryptHeader(e);
 
-    if (this.state.theirNostrPublicKey !== header.nextPublicKey) {
-      this.state.theirNostrPublicKey = header.nextPublicKey;
-      this.nostrUnsubscribe?.(); // should we keep this open for a while? maybe as long as we have skipped messages?
-      this.nostrUnsubscribe = this.nostrNextUnsubscribe;
-      this.nostrNextUnsubscribe = this.nostrSubscribe(
-        {authors: [this.state.theirNostrPublicKey], kinds: [EVENT_KIND]},
-        (e) => this.handleNostrEvent(e)
-      );
-    }
-
-    if (shouldRatchet) {
-      this.skipMessageKeys(header.previousChainLength, e.pubkey);
-      this.ratchetStep(header.nextPublicKey);
+    if (!isSkipped) {
+      if (this.state.theirNostrPublicKey !== header.nextPublicKey) {
+        this.state.theirNostrPublicKey = header.nextPublicKey;
+        this.nostrUnsubscribe?.(); // should we keep this open for a while? maybe as long as we have skipped messages?
+        this.nostrUnsubscribe = this.nostrNextUnsubscribe;
+        this.nostrNextUnsubscribe = this.nostrSubscribe(
+          {authors: [this.state.theirNostrPublicKey], kinds: [EVENT_KIND]},
+          (e) => this.handleNostrEvent(e)
+        );
+      }
+  
+      if (shouldRatchet) {
+        this.skipMessageKeys(header.previousChainLength, e.pubkey);
+        this.ratchetStep(header.nextPublicKey);
+      }
+    } else {
+      const key = skippedMessageIndexKey(e.pubkey, header.number);
+      if (!(key in this.state.skippedMessageKeys)) {
+        return // maybe we already processed this message
+      }
     }
 
     const data = this.ratchetDecrypt(header, e.content, e.pubkey);

package/src/InviteLink.ts

@@ -44,19 +44,26 @@ export class InviteLink {
 
     static fromUrl(url: string): InviteLink {
         const parsedUrl = new URL(url);
-        const inviter = parsedUrl.pathname.slice(1);
-        const inviterSessionPublicKey = parsedUrl.searchParams.get('s');
-        const linkSecret = parsedUrl.hash.slice(1);
-        
-        if (!inviter) {
-            throw new Error("Inviter not found in the URL");
+        const rawHash = parsedUrl.hash.slice(1);
+        if (!rawHash) {
+            throw new Error("No invite data found in the URL hash.");
         }
-        if (!inviterSessionPublicKey) {
-            throw new Error("Session key not found in the URL");
+
+        const decodedHash = decodeURIComponent(rawHash);
+        let data: any;
+        try {
+            data = JSON.parse(decodedHash);
+        } catch (err) {
+            throw new Error("Invite data in URL hash is not valid JSON: " + err);
+        }
+
+        const { inviter, sessionKey, linkSecret } = data;
+        if (!inviter || !sessionKey || !linkSecret) {
+            throw new Error("Missing required fields (inviter, sessionKey, linkSecret) in invite data.");
         }
 
         const decodedInviter = nip19.decode(inviter);
-        const decodedSessionKey = nip19.decode(inviterSessionPublicKey);
+        const decodedSessionKey = nip19.decode(sessionKey);
 
         if (typeof decodedInviter.data !== 'string') {
             throw new Error("Decoded inviter is not a string");
@@ -65,10 +72,11 @@ export class InviteLink {
             throw new Error("Decoded session key is not a string");
         }
 
-        const inviterHexPub = decodedInviter.data;
-        const inviterSessionPublicKeyHex = decodedSessionKey.data;
-        
-        return new InviteLink(inviterSessionPublicKeyHex, linkSecret, inviterHexPub);
+        return new InviteLink(
+            decodedSessionKey.data,
+            linkSecret,
+            decodedInviter.data
+        );
     }
 
     static deserialize(json: string): InviteLink {
@@ -97,10 +105,15 @@ export class InviteLink {
     }
 
     getUrl(root = "https://iris.to") {
-        const url = new URL(`${root}/${nip19.npubEncode(this.inviter)}`)
-        url.searchParams.set('s', nip19.npubEncode(this.inviterSessionPublicKey))
-        url.hash = this.linkSecret
-        return url.toString()
+        const data = {
+            inviter: nip19.npubEncode(this.inviter),
+            sessionKey: nip19.npubEncode(this.inviterSessionPublicKey),
+            linkSecret: this.linkSecret
+        };
+        const url = new URL(root);
+        url.hash = encodeURIComponent(JSON.stringify(data));
+        console.log('url', url.toString())
+        return url.toString();
     }
 
     /**

package/src/types.ts

@@ -63,6 +63,9 @@ export interface ChannelState {
   
   /** Cache of message keys for handling out-of-order messages */
   skippedMessageKeys: Record<string, Uint8Array>;
+
+  /** Cache of header keys for handling out-of-order messages */
+  skippedHeaderKeys: Record<string, Uint8Array[]>;
 }
 
 /**

package/src/utils.ts

@@ -27,6 +27,12 @@ export function serializeChannelState(state: ChannelState): string {
         bytesToHex(value),
       ])
     ),
+    skippedHeaderKeys: Object.fromEntries(
+      Object.entries(state.skippedHeaderKeys).map(([key, value]) => [
+        key,
+        value.map(bytes => bytesToHex(bytes))
+      ])
+    ),
   });
 }
 
@@ -54,6 +60,12 @@ export function deserializeChannelState(data: string): ChannelState {
         hexToBytes(value as string),
       ])
     ),
+    skippedHeaderKeys: Object.fromEntries(
+      Object.entries(state.skippedHeaderKeys || {}).map(([key, value]) => [
+        key,
+        (value as string[]).map(hex => hexToBytes(hex))
+      ])
+    ),
   };
 }