nostr-double-ratchet 0.0.27 → 0.0.29

package/src/StorageAdapter.ts

@@ -0,0 +1,43 @@
+/*
+ * Simple async key	value storage interface plus an in	memory implementation.
+ *
+ * All methods are Promise	based to accommodate back	ends like
+ * IndexedDB, SQLite, remote HTTP APIs, etc.  For environments where you only
+ * need ephemeral data (tests, Node scripts) the InMemoryStorageAdapter can be
+ * used directly.
+ */
+
+export interface StorageAdapter {
+  /** Retrieve a value by key. */
+  get<T = unknown>(key: string): Promise<T | undefined>
+  /** Store a value by key. */
+  put<T = unknown>(key: string, value: T): Promise<void>
+  /** Delete a stored value by key. */
+  del(key: string): Promise<void>
+  /** List all keys that start with the given prefix. */
+  list(prefix?: string): Promise<string[]>
+}
+
+export class InMemoryStorageAdapter implements StorageAdapter {
+  private store = new Map<string, unknown>()
+
+  async get<T = unknown>(key: string): Promise<T | undefined> {
+    return this.store.get(key) as T | undefined
+  }
+
+  async put<T = unknown>(key: string, value: T): Promise<void> {
+    this.store.set(key, value)
+  }
+
+  async del(key: string): Promise<void> {
+    this.store.delete(key)
+  }
+
+  async list(prefix = ''): Promise<string[]> {
+    const keys: string[] = []
+    for (const k of this.store.keys()) {
+      if (k.startsWith(prefix)) keys.push(k)
+    }
+    return keys
+  }
+} 

package/src/UserRecord.ts

@@ -19,9 +19,10 @@ export class UserRecord {
   private staleTimestamp?: number;
 
   constructor(
-    public userId: string,
-    private nostrSubscribe: NostrSubscribe,
-  ) {}
+    public _userId: string,
+    private _nostrSubscribe: NostrSubscribe,
+  ) {
+  }
 
   /**
    * Adds or updates a device record for this user
@@ -43,18 +44,7 @@ export class UserRecord {
    * 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;
+    this.upsertSession(deviceId, session)
   }
 
   /**
@@ -109,7 +99,7 @@ export class UserRecord {
     if (this.isStale) return [];
 
     return Array.from(this.deviceRecords.entries())
-      .filter(([_, record]) => !record.isStale && record.activeSession)
+      .filter(([, record]) => !record.isStale && record.activeSession)
       .map(([deviceId, record]) => [deviceId, record.activeSession!]);
   }
 
@@ -129,7 +119,7 @@ export class UserRecord {
     }
 
     const session = Session.init(
-      this.nostrSubscribe,
+      this._nostrSubscribe,
       record.publicKey,
       ourCurrentPrivateKey,
       isInitiator,
@@ -179,4 +169,71 @@ export class UserRecord {
     });
     this.deviceRecords.clear();
   }
-}
+
+  // ---------------------------------------------------------------------------
+  // Helper methods used by SessionManager (WIP):
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Return all sessions that are currently considered *active*.
+   * For now this means any session in a non-stale device record as well as
+   * all sessions added through `addSession`.
+   */
+  public getActiveSessions(): Session[] {
+    const sessions: Session[] = [];
+
+    for (const record of this.deviceRecords.values()) {
+      if (!record.isStale && record.activeSession) {
+        sessions.push(record.activeSession);
+      }
+    }
+
+    return sessions;
+  }
+
+  /**
+   * Return *all* sessions — active or inactive — that we have stored for this
+   * user. This is required for `SessionManager.onEvent` so that it can attach
+   * listeners to existing sessions.
+   */
+  public getAllSessions(): Session[] {
+    const sessions: Session[] = [];
+
+    for (const record of this.deviceRecords.values()) {
+      if (record.activeSession) {
+        sessions.push(record.activeSession);
+      }
+      sessions.push(...record.inactiveSessions);
+    }
+
+    return sessions;
+  }
+
+  /**
+   * Unified helper that either associates the session with a device record
+   * (if deviceId provided **and** the record exists) or falls back to the
+   * legacy extraSessions list.
+   */
+  public upsertSession(deviceId: string | undefined, session: Session) {
+    if (!deviceId) {
+      deviceId = 'unknown'
+    }
+
+    let record = this.deviceRecords.get(deviceId)
+    if (!record) {
+      record = {
+        publicKey: session.state?.theirNextNostrPublicKey || '',
+        inactiveSessions: [],
+        isStale: false
+      }
+      this.deviceRecords.set(deviceId, record)
+    }
+
+    if (record.activeSession) {
+      record.inactiveSessions.unshift(record.activeSession)
+    }
+    // Ensure session name matches deviceId for easier identification
+    session.name = deviceId
+    record.activeSession = session
+  }
+}

package/src/index.ts

@@ -1,4 +1,5 @@
-export * from "./Session.ts"
+export * from "./Session"
 export * from "./Invite"
 export * from "./types"
-export * from "./utils"
+export * from "./utils"
+export * from "./SessionManager"

package/src/types.ts

@@ -65,18 +65,19 @@ export type Unsubscribe = () => void;
 /** 
  * Function that subscribes to Nostr events matching a filter and calls onEvent for each event.
  */
-export type NostrSubscribe = (filter: Filter, onEvent: (e: VerifiedEvent) => void) => Unsubscribe;
-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>;
+export type NostrSubscribe = (_filter: Filter, _onEvent: (_e: VerifiedEvent) => void) => Unsubscribe;
+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>;
 
 export type Rumor = UnsignedEvent & { id: string }
 
 /** 
  * Callback function for handling decrypted messages
- * @param message - The decrypted message object
+ * @param _event - The decrypted message object (Rumor)
+ * @param _outerEvent - The outer Nostr event (VerifiedEvent)
  */
-export type EventCallback = (event: Rumor, outerEvent: VerifiedEvent) => void;
+export type EventCallback = (_event: Rumor, _outerEvent: VerifiedEvent) => void;
 
 /**
  * Message event kind

package/src/utils.ts

@@ -51,10 +51,10 @@ export function deserializeSessionState(data: string): SessionState {
     
     // Migrate old skipped keys format to new structure
     if (state.skippedMessageKeys) {
-      Object.entries(state.skippedMessageKeys).forEach(([pubKey, messageKeys]: [string, any]) => {
+      Object.entries(state.skippedMessageKeys).forEach(([pubKey, messageKeys]: [string, unknown]) => {
         skippedKeys[pubKey] = {
           headerKeys: state.skippedHeaderKeys?.[pubKey] || [],
-          messageKeys: messageKeys
+          messageKeys: messageKeys as { [msgIndex: number]: Uint8Array }
         };
       });
     }
@@ -102,9 +102,9 @@ export function deserializeSessionState(data: string): SessionState {
       Object.entries(state.skippedKeys || {}).map(([pubKey, value]) => [
         pubKey,
         {
-          headerKeys: (value as any).headerKeys.map((hex: string) => hexToBytes(hex)),
+          headerKeys: (value as { headerKeys: string[] }).headerKeys.map((hex: string) => hexToBytes(hex)),
           messageKeys: Object.fromEntries(
-            Object.entries((value as any).messageKeys).map(([msgIndex, hex]) => [
+            Object.entries((value as { messageKeys: Record<string, string> }).messageKeys).map(([msgIndex, hex]) => [
               msgIndex,
               hexToBytes(hex as string)
             ])
@@ -117,14 +117,14 @@ export function deserializeSessionState(data: string): SessionState {
 
 export async function* createEventStream(session: Session): AsyncGenerator<Rumor, void, unknown> {
   const messageQueue: Rumor[] = [];
-  let resolveNext: ((value: Rumor) => void) | null = null;
+  let resolveNext: ((_value: Rumor) => void) | null = null;
 
-  const unsubscribe = session.onEvent((event) => {
+  const unsubscribe = session.onEvent((_event) => {
     if (resolveNext) {
-      resolveNext(event);
+      resolveNext(_event);
       resolveNext = null;
     } else {
-      messageQueue.push(event);
+      messageQueue.push(_event);
     }
   });
 
@@ -153,14 +153,14 @@ export function kdf(input1: Uint8Array, input2: Uint8Array = new Uint8Array(32),
   return outputs;
 }
 
-export function skippedMessageIndexKey(nostrSender: string, number: number): string {
-  return `${nostrSender}:${number}`;
+export function skippedMessageIndexKey(_nostrSender: string, _number: number): string {
+  return `${_nostrSender}:${_number}`;
 }
 
 export function getMillisecondTimestamp(event: Rumor) {
-  const msTag = event.tags?.find(tag => tag[0] === "ms");
+  const msTag = event.tags?.find((tag: string[]) => tag[0] === "ms");
   if (msTag) {
     return parseInt(msTag[1]);
   }
   return event.created_at * 1000;
-}
+}