nostr-double-ratchet 0.0.13 → 0.0.15

package/src/Invite.ts

@@ -1,9 +1,7 @@
 import { generateSecretKey, getPublicKey, nip44, finalizeEvent, VerifiedEvent, UnsignedEvent, verifyEvent, Filter } from "nostr-tools";
-import { INVITE_EVENT_KIND, NostrSubscribe, Unsubscribe } from "./types";
+import { INVITE_EVENT_KIND, NostrSubscribe, Unsubscribe, MESSAGE_EVENT_KIND, EncryptFunction, DecryptFunction } from "./types";
 import { getConversationKey } from "nostr-tools/nip44";
 import { Session } from "./Session.ts";
-import { MESSAGE_EVENT_KIND } from "./types";
-import { EncryptFunction, DecryptFunction } from "./types";
 import { hexToBytes, bytesToHex } from "@noble/hashes/utils";
 
 /**
@@ -19,7 +17,7 @@ import { hexToBytes, bytesToHex } from "@noble/hashes/utils";
 export class Invite {
     constructor(
         public inviterEphemeralPublicKey: string,
-        public linkSecret: string,
+        public sharedSecret: string,
         public inviter: string,
         public inviterEphemeralPrivateKey?: Uint8Array,
         public label?: string,
@@ -33,10 +31,10 @@ export class Invite {
         }
         const inviterEphemeralPrivateKey = generateSecretKey();
         const inviterEphemeralPublicKey = getPublicKey(inviterEphemeralPrivateKey);
-        const linkSecret = bytesToHex(generateSecretKey());
+        const sharedSecret = bytesToHex(generateSecretKey());
         return new Invite(
             inviterEphemeralPublicKey,
-            linkSecret,
+            sharedSecret,
             inviter,
             inviterEphemeralPrivateKey,
             label,
@@ -59,14 +57,14 @@ export class Invite {
             throw new Error("Invite data in URL hash is not valid JSON: " + err);
         }
 
-        const { inviter, ephemeralKey, linkSecret } = data;
-        if (!inviter || !ephemeralKey || !linkSecret) {
-            throw new Error("Missing required fields (inviter, ephemeralKey, linkSecret) in invite data.");
+        const { inviter, ephemeralKey, sharedSecret } = data;
+        if (!inviter || !ephemeralKey || !sharedSecret) {
+            throw new Error("Missing required fields (inviter, ephemeralKey, sharedSecret) in invite data.");
         }
 
         return new Invite(
             ephemeralKey,
-            linkSecret,
+            sharedSecret,
             inviter
         );
     }
@@ -75,7 +73,7 @@ export class Invite {
         const data = JSON.parse(json);
         return new Invite(
             data.inviterEphemeralPublicKey,
-            data.linkSecret,
+            data.sharedSecret,
             data.inviter,
             data.inviterEphemeralPrivateKey ? new Uint8Array(data.inviterEphemeralPrivateKey) : undefined,
             data.label,
@@ -93,16 +91,16 @@ export class Invite {
         }
         const { tags } = event;
         const inviterEphemeralPublicKey = tags.find(([key]) => key === 'ephemeralKey')?.[1];
-        const linkSecret = tags.find(([key]) => key === 'linkSecret')?.[1];
+        const sharedSecret = tags.find(([key]) => key === 'sharedSecret')?.[1];
         const inviter = event.pubkey;
 
-        if (!inviterEphemeralPublicKey || !linkSecret) {
-            throw new Error("Invalid invite event: missing session key or link secret");
+        if (!inviterEphemeralPublicKey || !sharedSecret) {
+            throw new Error("Invalid invite event: missing session key or sharedSecret");
         }
 
         return new Invite(
             inviterEphemeralPublicKey,
-            linkSecret,
+            sharedSecret,
             inviter
         );
     }
@@ -137,7 +135,7 @@ export class Invite {
     serialize(): string {
         return JSON.stringify({
             inviterEphemeralPublicKey: this.inviterEphemeralPublicKey,
-            linkSecret: this.linkSecret,
+            sharedSecret: this.sharedSecret,
             inviter: this.inviter,
             inviterEphemeralPrivateKey: this.inviterEphemeralPrivateKey ? Array.from(this.inviterEphemeralPrivateKey) : undefined,
             label: this.label,
@@ -153,11 +151,10 @@ export class Invite {
         const data = {
             inviter: this.inviter,
             ephemeralKey: this.inviterEphemeralPublicKey,
-            linkSecret: this.linkSecret
+            sharedSecret: this.sharedSecret
         };
         const url = new URL(root);
         url.hash = encodeURIComponent(JSON.stringify(data));
-        console.log('url', url.toString())
         return url.toString();
     }
 
@@ -167,7 +164,7 @@ export class Invite {
             pubkey: this.inviter,
             content: "",
             created_at: Math.floor(Date.now() / 1000),
-            tags: [['ephemeralKey', this.inviterEphemeralPublicKey], ['linkSecret', this.linkSecret], ['d', 'nostr-double-ratchet/invite']],
+            tags: [['ephemeralKey', this.inviterEphemeralPublicKey], ['sharedSecret', this.sharedSecret], ['d', 'nostr-double-ratchet/invite']],
         };
     }
 
@@ -189,27 +186,31 @@ export class Invite {
     async accept(
         nostrSubscribe: NostrSubscribe,
         inviteePublicKey: string,
-        inviteeSecretKey: Uint8Array | EncryptFunction,
+        encryptor: Uint8Array | EncryptFunction,
     ): Promise<{ session: Session, event: VerifiedEvent }> {
         const inviteeSessionKey = generateSecretKey();
         const inviteeSessionPublicKey = getPublicKey(inviteeSessionKey);
         const inviterPublicKey = this.inviter || this.inviterEphemeralPublicKey;
 
-        const sharedSecret = hexToBytes(this.linkSecret);
+        const sharedSecret = hexToBytes(this.sharedSecret);
         const session = Session.init(nostrSubscribe, this.inviterEphemeralPublicKey, inviteeSessionKey, true, sharedSecret, undefined);
 
         // Create a random keypair for the envelope sender
         const randomSenderKey = generateSecretKey();
         const randomSenderPublicKey = getPublicKey(randomSenderKey);
 
-        const encrypt = typeof inviteeSecretKey === 'function' ?
-            inviteeSecretKey :
-            (plaintext: string, pubkey: string) => Promise.resolve(nip44.encrypt(plaintext, getConversationKey(inviteeSecretKey, pubkey)));
+        // should we take only Encrypt / Decrypt functions, not keys, to make it simpler and with less imports here?
+        // common implementation problem: plaintext, pubkey params in different order
+        const encrypt = typeof encryptor === 'function' ?
+            encryptor :
+            (plaintext: string, pubkey: string) => Promise.resolve(nip44.encrypt(plaintext, getConversationKey(encryptor, pubkey)));
+
+        const dhEncrypted = await encrypt(inviteeSessionPublicKey, inviterPublicKey);
 
         const innerEvent = {
             pubkey: inviteePublicKey,
-            tags: [['secret', this.linkSecret]],
-            content: await encrypt(inviteeSessionPublicKey, inviterPublicKey),
+            tags: [['sharedSecret', this.sharedSecret]],
+            content: await nip44.encrypt(dhEncrypted, sharedSecret),
             created_at: Math.floor(Date.now() / 1000),
         };
 
@@ -224,7 +225,7 @@ export class Invite {
         return { session, event: finalizeEvent(envelope, randomSenderKey) };
     }
 
-    listen(inviterSecretKey: 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");
         }
@@ -241,23 +242,28 @@ export class Invite {
                     return;
                 }
 
+                // Decrypt the outer envelope first
                 const decrypted = await nip44.decrypt(event.content, getConversationKey(this.inviterEphemeralPrivateKey!, event.pubkey));
                 const innerEvent = JSON.parse(decrypted);
 
-                if (!innerEvent.tags || !innerEvent.tags.some(([key, value]: [string, string]) => key === 'secret' && value === this.linkSecret)) {
+                if (!innerEvent.tags || !innerEvent.tags.some(([key, value]: [string, string]) => key === 'sharedSecret' && value === this.sharedSecret)) {
                     console.error("Invalid secret from event", event);
                     return;
                 }
 
-                const innerDecrypt = typeof inviterSecretKey === 'function' ?
-                    inviterSecretKey :
-                    (ciphertext: string, pubkey: string) => Promise.resolve(nip44.decrypt(ciphertext, getConversationKey(inviterSecretKey, pubkey)));
-    
+                const sharedSecret = hexToBytes(this.sharedSecret);
                 const inviteeIdentity = innerEvent.pubkey;
                 this.usedBy.push(inviteeIdentity);
 
-                const inviteeSessionPublicKey = await innerDecrypt(innerEvent.content, inviteeIdentity);
-                const sharedSecret = hexToBytes(this.linkSecret);
+                // Decrypt the inner content using shared secret first
+                const dhEncrypted = await nip44.decrypt(innerEvent.content, sharedSecret);
+
+                // Then decrypt using DH key
+                const innerDecrypt = typeof decryptor === 'function' ?
+                    decryptor :
+                    (ciphertext: string, pubkey: string) => Promise.resolve(nip44.decrypt(ciphertext, getConversationKey(decryptor, pubkey)));
+
+                const inviteeSessionPublicKey = await innerDecrypt(dhEncrypted, inviteeIdentity);
 
                 const name = event.id;
                 const session = Session.init(nostrSubscribe, inviteeSessionPublicKey, this.inviterEphemeralPrivateKey!, false, sharedSecret, name);

package/src/Session.ts

@@ -1,17 +1,22 @@
-import { generateSecretKey, getPublicKey, nip44, finalizeEvent, VerifiedEvent } from "nostr-tools";
+import { generateSecretKey, getPublicKey, nip44, finalizeEvent, VerifiedEvent, UnsignedEvent, getEventHash } from "nostr-tools";
 import { bytesToHex } from "@noble/hashes/utils";
 import {
   SessionState,
   Header,
   Unsubscribe,
   NostrSubscribe,
-  MessageCallback,
+  EventCallback,
   MESSAGE_EVENT_KIND,
+  Rumor,
+  CHAT_MESSAGE_KIND,
 } from "./types";
 import { kdf, skippedMessageIndexKey } from "./utils";
 
 const MAX_SKIP = 1000;
 
+// 64 zeros
+const DUMMY_PUBKEY = '0000000000000000000000000000000000000000000000000000000000000000'
+
 /**
  * Double ratchet secure communication session over Nostr
  * 
@@ -21,7 +26,7 @@ const MAX_SKIP = 1000;
 export class Session {
   private nostrUnsubscribe?: Unsubscribe;
   private nostrNextUnsubscribe?: Unsubscribe;
-  private internalSubscriptions = new Map<number, MessageCallback>();
+  private internalSubscriptions = new Map<number, EventCallback>();
   private currentInternalSubscriptionId = 0;
   public name: string;
 
@@ -33,16 +38,16 @@ export class Session {
   /**
    * Initializes a new secure communication session
    * @param nostrSubscribe Function to subscribe to Nostr events
-   * @param theirNostrPublicKey The public key of the other party
+   * @param theirNextNostrPublicKey The public key of the other party
    * @param ourCurrentPrivateKey Our current private key for Nostr
    * @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)
    * @returns A new Session instance
    */
-  static init(nostrSubscribe: NostrSubscribe, theirNostrPublicKey: string, ourCurrentPrivateKey: Uint8Array, isInitiator: boolean, sharedSecret: Uint8Array, name?: string): Session {
+  static init(nostrSubscribe: NostrSubscribe, theirNextNostrPublicKey: string, ourCurrentPrivateKey: Uint8Array, isInitiator: boolean, sharedSecret: Uint8Array, name?: string): Session {
     const ourNextPrivateKey = generateSecretKey();
-    const [rootKey, sendingChainKey] = kdf(sharedSecret, nip44.getConversationKey(ourNextPrivateKey, theirNostrPublicKey), 2);
+    const [rootKey, sendingChainKey] = kdf(sharedSecret, nip44.getConversationKey(ourNextPrivateKey, theirNextNostrPublicKey), 2);
     let ourCurrentNostrKey;
     let ourNextNostrKey;
     if (isInitiator) {
@@ -53,7 +58,7 @@ export class Session {
     }
     const state: SessionState = {
       rootKey: isInitiator ? rootKey : sharedSecret,
-      theirNostrPublicKey,
+      theirNextNostrPublicKey,
       ourCurrentNostrKey,
       ourNextNostrKey,
       receivingChainKey: undefined,
@@ -70,19 +75,51 @@ export class Session {
   }
 
   /**
-   * Sends an encrypted message through the session
-   * @param data The plaintext message to send
+   * Sends a text message through the encrypted session
+   * @param text The plaintext message to send
+   * @returns A verified Nostr event containing the encrypted message
+   * @throws Error if we are not the initiator and trying to send the first message
+   */
+  send(text: string): VerifiedEvent {
+    return this.sendEvent({
+      content: text,
+      kind: CHAT_MESSAGE_KIND
+    });
+  }
+
+  /**
+   * Send a Nostr event through the encrypted session
+   * @param event Partial Nostr event to send. Must be unsigned. Id and will be generated if not provided.
    * @returns A verified Nostr event containing the encrypted message
    * @throws Error if we are not the initiator and trying to send the first message
    */
-  send(data: string): VerifiedEvent {
-    if (!this.state.theirNostrPublicKey || !this.state.ourCurrentNostrKey) {
+  sendEvent(event: Partial<UnsignedEvent>): VerifiedEvent {
+    if (!this.state.theirNextNostrPublicKey || !this.state.ourCurrentNostrKey) {
       throw new Error("we are not the initiator, so we can't send the first message");
     }
 
-    const [header, encryptedData] = this.ratchetEncrypt(data);
+    if ("sig" in event) {
+      throw new Error("Event must be unsigned " + JSON.stringify(event));
+    }
+
+    const rumor: Partial<Rumor> = {
+      ...event,
+      content: event.content || "",
+      kind: event.kind || MESSAGE_EVENT_KIND,
+      created_at: event.created_at || Math.floor(Date.now() / 1000),
+      tags: event.tags || [],
+      pubkey: event.pubkey || DUMMY_PUBKEY,
+    }
+
+    if (!rumor.tags!.some(([k]) => k === "ms")) {
+      rumor.tags!.push(["ms", Date.now().toString()])
+    }
+
+    rumor.id = getEventHash(rumor as Rumor);
+
+    const [header, encryptedData] = this.ratchetEncrypt(JSON.stringify(event));
     
-    const sharedSecret = nip44.getConversationKey(this.state.ourCurrentNostrKey.privateKey, this.state.theirNostrPublicKey);
+    const sharedSecret = nip44.getConversationKey(this.state.ourCurrentNostrKey.privateKey, this.state.theirNextNostrPublicKey);
     const encryptedHeader = nip44.encrypt(JSON.stringify(header), sharedSecret);
     
     const nostrEvent = finalizeEvent({
@@ -100,7 +137,7 @@ export class Session {
    * @param callback Function to be called when a message is received
    * @returns Unsubscribe function to stop receiving messages
    */
-  onMessage(callback: MessageCallback): Unsubscribe {
+  onEvent(callback: EventCallback): Unsubscribe {
     const id = this.currentInternalSubscriptionId++
     this.internalSubscriptions.set(id, callback)
     this.subscribeToNostrEvents()
@@ -122,7 +159,6 @@ export class Session {
     const header: Header = {
       number: this.state.sendingChainMessageNumber++,
       nextPublicKey: this.state.ourNextNostrKey.publicKey,
-      time: Date.now(),
       previousChainLength: this.state.previousSendingChainMessageCount
     };
     return [header, nip44.encrypt(plaintext, messageKey)];
@@ -151,13 +187,13 @@ export class Session {
     }
   }
 
-  private ratchetStep(theirNostrPublicKey: string) {
+  private ratchetStep(theirNextNostrPublicKey: string) {
     this.state.previousSendingChainMessageCount = this.state.sendingChainMessageNumber;
     this.state.sendingChainMessageNumber = 0;
     this.state.receivingChainMessageNumber = 0;
-    this.state.theirNostrPublicKey = theirNostrPublicKey;
+    this.state.theirNextNostrPublicKey = theirNextNostrPublicKey;
 
-    const conversationKey1 = nip44.getConversationKey(this.state.ourNextNostrKey.privateKey, this.state.theirNostrPublicKey!);
+    const conversationKey1 = nip44.getConversationKey(this.state.ourNextNostrKey.privateKey, this.state.theirNextNostrPublicKey!);
     const [theirRootKey, receivingChainKey] = kdf(this.state.rootKey, conversationKey1, 2);
 
     this.state.receivingChainKey = receivingChainKey;
@@ -169,7 +205,7 @@ export class Session {
       privateKey: ourNextSecretKey
     };
 
-    const conversationKey2 = nip44.getConversationKey(this.state.ourNextNostrKey.privateKey, this.state.theirNostrPublicKey!);
+    const conversationKey2 = nip44.getConversationKey(this.state.ourNextNostrKey.privateKey, this.state.theirNextNostrPublicKey!);
     const [rootKey, sendingChainKey] = kdf(theirRootKey, conversationKey2, 2);
     this.state.rootKey = rootKey;
     this.state.sendingChainKey = sendingChainKey;
@@ -261,12 +297,13 @@ export class Session {
     const [header, shouldRatchet, isSkipped] = this.decryptHeader(e);
 
     if (!isSkipped) {
-      if (this.state.theirNostrPublicKey !== header.nextPublicKey) {
-        this.state.theirNostrPublicKey = header.nextPublicKey;
+      if (this.state.theirNextNostrPublicKey !== header.nextPublicKey) {
+        this.state.theirCurrentNostrPublicKey = this.state.theirNextNostrPublicKey;
+        this.state.theirNextNostrPublicKey = 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: [MESSAGE_EVENT_KIND]},
+          {authors: [this.state.theirNextNostrPublicKey], kinds: [MESSAGE_EVENT_KIND]},
           (e) => this.handleNostrEvent(e)
         );
       }
@@ -282,26 +319,28 @@ export class Session {
       }
     }
 
-    const data = this.ratchetDecrypt(header, e.content, e.pubkey);
+    const text = this.ratchetDecrypt(header, e.content, e.pubkey);
+    const innerEvent = JSON.parse(text);
 
-    this.internalSubscriptions.forEach(callback => callback({id: e.id, data, pubkey: header.nextPublicKey, time: header.time}));  
+    this.internalSubscriptions.forEach(callback => callback(innerEvent, e));  
   }
 
   private subscribeToNostrEvents() {
     if (this.nostrNextUnsubscribe) return;
     this.nostrNextUnsubscribe = this.nostrSubscribe(
-      {authors: [this.state.theirNostrPublicKey], kinds: [MESSAGE_EVENT_KIND]},
+      {authors: [this.state.theirNextNostrPublicKey], kinds: [MESSAGE_EVENT_KIND]},
       (e) => this.handleNostrEvent(e)
     );
 
-    const skippedSenders = Object.keys(this.state.skippedHeaderKeys);
-    if (skippedSenders.length > 0) {
-      // do we want this unsubscribed on rotation or should we keep it open
-      // in case more skipped messages are found by relays or peers?
-      this.nostrUnsubscribe = this.nostrSubscribe(
-        {authors: skippedSenders, kinds: [MESSAGE_EVENT_KIND]},
-        (e) => this.handleNostrEvent(e)
-      );
+    const authors = Object.keys(this.state.skippedHeaderKeys);
+    if (this.state.theirCurrentNostrPublicKey && !authors.includes(this.state.theirCurrentNostrPublicKey)) {
+      authors.push(this.state.theirCurrentNostrPublicKey)
     }
+    // do we want this unsubscribed on rotation or should we keep it open
+    // in case more skipped messages are found by relays or peers?
+    this.nostrUnsubscribe = this.nostrSubscribe(
+      {authors, kinds: [MESSAGE_EVENT_KIND]},
+      (e) => this.handleNostrEvent(e)
+    );
   }
 }

package/src/UserRecord.ts

@@ -0,0 +1,182 @@
+import { Session } from './Session';
+import { NostrSubscribe } from './types';
+
+interface DeviceRecord {
+  publicKey: string;
+  activeSession?: Session;
+  inactiveSessions: Session[];
+  isStale: boolean;
+  staleTimestamp?: number;
+}
+
+/**
+ * WIP: Conversation management system similar to Signal's Sesame
+ * https://signal.org/docs/specifications/sesame/
+ */
+export class UserRecord {
+  private deviceRecords: Map<string, DeviceRecord> = new Map();
+  private isStale: boolean = false;
+  private staleTimestamp?: number;
+
+  constructor(
+    public userId: string,
+    private nostrSubscribe: NostrSubscribe,
+  ) {}
+
+  /**
+   * Adds or updates a device record for this user
+   */
+  public conditionalUpdate(deviceId: string, publicKey: string): void {
+    const existingRecord = this.deviceRecords.get(deviceId);
+    
+    // If device record doesn't exist or public key changed, create new empty record
+    if (!existingRecord || existingRecord.publicKey !== publicKey) {
+      this.deviceRecords.set(deviceId, {
+        publicKey,
+        inactiveSessions: [],
+        isStale: false
+      });
+    }
+  }
+
+  /**
+   * Inserts a new session for a device, making it the active session
+   */
+  public insertSession(deviceId: string, session: Session): void {
+    const record = this.deviceRecords.get(deviceId);
+    if (!record) {
+      throw new Error(`No device record found for ${deviceId}`);
+    }
+
+    // Move current active session to inactive list if it exists
+    if (record.activeSession) {
+      record.inactiveSessions.unshift(record.activeSession);
+    }
+
+    // Set new session as active
+    record.activeSession = session;
+  }
+
+  /**
+   * Activates an inactive session for a device
+   */
+  public activateSession(deviceId: string, session: Session): void {
+    const record = this.deviceRecords.get(deviceId);
+    if (!record) {
+      throw new Error(`No device record found for ${deviceId}`);
+    }
+
+    const sessionIndex = record.inactiveSessions.indexOf(session);
+    if (sessionIndex === -1) {
+      throw new Error('Session not found in inactive sessions');
+    }
+
+    // Remove session from inactive list
+    record.inactiveSessions.splice(sessionIndex, 1);
+
+    // Move current active session to inactive list if it exists
+    if (record.activeSession) {
+      record.inactiveSessions.unshift(record.activeSession);
+    }
+
+    // Set selected session as active
+    record.activeSession = session;
+  }
+
+  /**
+   * Marks a device record as stale
+   */
+  public markDeviceStale(deviceId: string): void {
+    const record = this.deviceRecords.get(deviceId);
+    if (record) {
+      record.isStale = true;
+      record.staleTimestamp = Date.now();
+    }
+  }
+
+  /**
+   * Marks the entire user record as stale
+   */
+  public markUserStale(): void {
+    this.isStale = true;
+    this.staleTimestamp = Date.now();
+  }
+
+  /**
+   * Gets all non-stale device records with active sessions
+   */
+  public getActiveDevices(): Array<[string, Session]> {
+    if (this.isStale) return [];
+
+    return Array.from(this.deviceRecords.entries())
+      .filter(([_, record]) => !record.isStale && record.activeSession)
+      .map(([deviceId, record]) => [deviceId, record.activeSession!]);
+  }
+
+  /**
+   * Creates a new session for a device
+   */
+  public createSession(
+    deviceId: string, 
+    sharedSecret: Uint8Array,
+    ourCurrentPrivateKey: Uint8Array,
+    isInitiator: boolean,
+    name?: string
+  ): Session {
+    const record = this.deviceRecords.get(deviceId);
+    if (!record) {
+      throw new Error(`No device record found for ${deviceId}`);
+    }
+
+    const session = Session.init(
+      this.nostrSubscribe,
+      record.publicKey,
+      ourCurrentPrivateKey,
+      isInitiator,
+      sharedSecret,
+      name
+    );
+
+    this.insertSession(deviceId, session);
+    return session;
+  }
+
+  /**
+   * Deletes stale records that are older than maxLatency
+   */
+  public pruneStaleRecords(maxLatency: number): void {
+    const now = Date.now();
+
+    // Delete stale device records
+    for (const [deviceId, record] of this.deviceRecords.entries()) {
+      if (record.isStale && record.staleTimestamp && 
+          (now - record.staleTimestamp) > maxLatency) {
+        // Close all sessions
+        record.activeSession?.close();
+        record.inactiveSessions.forEach(session => session.close());
+        this.deviceRecords.delete(deviceId);
+      }
+    }
+
+    // Delete entire user record if stale
+    if (this.isStale && this.staleTimestamp && 
+        (now - this.staleTimestamp) > maxLatency) {
+      this.deviceRecords.forEach(record => {
+        record.activeSession?.close();
+        record.inactiveSessions.forEach(session => session.close());
+      });
+      this.deviceRecords.clear();
+    }
+  }
+
+  /**
+   * Cleanup when destroying the user record
+   */
+  public close(): void {
+    this.deviceRecords.forEach(record => {
+      record.activeSession?.close();
+      record.inactiveSessions.forEach(session => session.close());
+    });
+    this.deviceRecords.clear();
+  }
+}

package/src/types.ts

@@ -1,20 +1,9 @@
 import { Filter, UnsignedEvent, VerifiedEvent } from "nostr-tools";
 
-/**
- * An event that has been verified to be from the Nostr network.
- */
-export type Message = {
-  id: string;
-  data: string;
-  pubkey: string;
-  time: number; // unlike Nostr, we use milliseconds instead of seconds
-}
-
 export type Header = {
   number: number;
   previousChainLength: number;
   nextPublicKey: string;
-  time: number;
 }
 
 /**
@@ -33,7 +22,10 @@ export interface SessionState {
   rootKey: Uint8Array;
   
   /** The other party's current Nostr public key */
-  theirNostrPublicKey: string;
+  theirCurrentNostrPublicKey?: string;
+
+  /** The other party's next Nostr public key */
+  theirNextNostrPublicKey: string;
 
   /** Our current Nostr keypair used for this session */
   ourCurrentNostrKey?: KeyPair;
@@ -73,14 +65,26 @@ export type Unsubscribe = () => void;
  */
 export type NostrSubscribe = (filter: Filter, onEvent: (e: VerifiedEvent) => void) => Unsubscribe;
 
+export type Rumor = UnsignedEvent & { id: string }
+
 /** 
  * Callback function for handling decrypted messages
  * @param message - The decrypted message object
  */
-export type MessageCallback = (message: Message) => void;
+export type EventCallback = (event: Rumor, outerEvent: VerifiedEvent) => void;
 
-export const MESSAGE_EVENT_KIND = 4;
+/**
+ * Message event kind
+ */
+export const MESSAGE_EVENT_KIND = 30078;
+
+/**
+ * Invite event kind
+ */
 export const INVITE_EVENT_KIND = 30078;
+
+export const CHAT_MESSAGE_KIND = 14;
+
 export const MAX_SKIP = 100;
 
 export type NostrEvent = {
@@ -93,11 +97,6 @@ export type NostrEvent = {
   sig: string;
 }
 
-export enum Sender {
-  Us,
-  Them
-}
-
 export type EncryptFunction = (plaintext: string, pubkey: string) => Promise<string>;
 export type DecryptFunction = (ciphertext: string, pubkey: string) => Promise<string>;
 export type NostrPublish = (event: UnsignedEvent) => Promise<VerifiedEvent>;