nostr-double-ratchet 0.0.28 → 0.0.30

package/src/Invite.ts

@@ -25,13 +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");
         }
@@ -43,7 +43,7 @@ export class Invite {
             sharedSecret,
             inviter,
             inviterEphemeralPrivateKey,
-            label,
+            deviceId,
             maxUses
         );
     }
@@ -82,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
         );
@@ -105,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");
         }
@@ -112,7 +116,9 @@ export class Invite {
         return new Invite(
             inviterEphemeralPublicKey,
             sharedSecret,
-            inviter
+            inviter,
+            undefined, // inviterEphemeralPrivateKey not available when parsing from event
+            deviceId
         );
     }
 
@@ -122,12 +128,10 @@ export class Invite {
             authors: [user],
             "#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);
@@ -147,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,
         });
@@ -167,9 +171,9 @@ export class Invite {
         return url.toString();
     }
 
-    getEvent(deviceName: string): UnsignedEvent {
-        if (!deviceName) {
-            throw new Error("Device name is required");
+    getEvent(): UnsignedEvent {
+        if (!this.deviceId) {
+            throw new Error("Device ID is required");
         }
         return {
             kind: INVITE_EVENT_KIND,
@@ -179,7 +183,7 @@ export class Invite {
             tags: [
                 ['ephemeralKey', this.inviterEphemeralPublicKey],
                 ['sharedSecret', this.sharedSecret],
-                ['d', 'double-ratchet/invites/' + deviceName],
+                ['d', 'double-ratchet/invites/' + this.deviceId],
                 ['l', 'double-ratchet/invites']
             ],
         };
@@ -187,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).

package/src/Session.ts

@@ -38,9 +38,9 @@ export class Session {
 
   /**
    * Initializes a new secure communication session
-   * @param nostrSubscribe Function to subscribe to Nostr events. Make sure it deduplicates events (doesnt return the same event twice), otherwise you'll see decryption errors!
-   * @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)
@@ -320,42 +320,49 @@ export class Session {
   }
 
   private handleNostrEvent(e: { tags: string[][]; pubkey: string; content: string }) {
-    const [header, shouldRatchet, isSkipped] = this.decryptHeader(e);
-
-    if (!isSkipped) {
-      if (this.state.theirNextNostrPublicKey !== header.nextPublicKey) {
-        this.state.theirCurrentNostrPublicKey = this.state.theirNextNostrPublicKey;
-        this.state.theirNextNostrPublicKey = header.nextPublicKey;
-        this.nostrUnsubscribe?.();
-        this.nostrUnsubscribe = this.nostrNextUnsubscribe;
-        this.nostrNextUnsubscribe = this.nostrSubscribe(
-          {authors: [this.state.theirNextNostrPublicKey], kinds: [MESSAGE_EVENT_KIND]},
-          (e) => this.handleNostrEvent(e)
-        );
-      }
-  
-      if (shouldRatchet) {
-        this.skipMessageKeys(header.previousChainLength, e.pubkey);
-        this.ratchetStep();
+    try {
+      const [header, shouldRatchet, isSkipped] = this.decryptHeader(e);
+
+      if (!isSkipped) {
+        if (this.state.theirNextNostrPublicKey !== header.nextPublicKey) {
+          this.state.theirCurrentNostrPublicKey = this.state.theirNextNostrPublicKey;
+          this.state.theirNextNostrPublicKey = header.nextPublicKey;
+          this.nostrUnsubscribe?.();
+          this.nostrUnsubscribe = this.nostrNextUnsubscribe;
+          this.nostrNextUnsubscribe = this.nostrSubscribe(
+            {authors: [this.state.theirNextNostrPublicKey], kinds: [MESSAGE_EVENT_KIND]},
+            (e) => this.handleNostrEvent(e)
+          );
+        }
+    
+        if (shouldRatchet) {
+          this.skipMessageKeys(header.previousChainLength, e.pubkey);
+          this.ratchetStep();
+        }
+      } else {
+        if (!this.state.skippedKeys[e.pubkey]?.messageKeys[header.number]) {
+          // Maybe we already processed this message — no error
+          return
+        }
       }
-    } else {
-      if (!this.state.skippedKeys[e.pubkey]?.messageKeys[header.number]) {
-        // Maybe we already processed this message — no error
-        return
+
+      const text = this.ratchetDecrypt(header, e.content, e.pubkey);
+      const innerEvent = JSON.parse(text);
+      if (!validateEvent(innerEvent)) {
+        return;
       }
-    }
 
-    const text = this.ratchetDecrypt(header, e.content, e.pubkey);
-    const innerEvent = JSON.parse(text);
-    if (!validateEvent(innerEvent)) {
-      return;
-    }
+      if (innerEvent.id !== getEventHash(innerEvent)) {
+        return;
+      }
 
-    if (innerEvent.id !== getEventHash(innerEvent)) {
-      return;
+      this.internalSubscriptions.forEach(callback => callback(innerEvent, e as VerifiedEvent));  
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Failed to decrypt header")) {
+        return;
+      }
+      throw error;
     }
-
-    this.internalSubscriptions.forEach(callback => callback(innerEvent, e as VerifiedEvent));  
   }
 
   private subscribeToNostrEvents() {

package/src/SessionManager.ts

@@ -2,6 +2,9 @@ import { CHAT_MESSAGE_KIND, NostrPublish, NostrSubscribe, Rumor, Unsubscribe } f
 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()
@@ -9,13 +12,182 @@ export default class SessionManager {
     private nostrPublish: NostrPublish
     private ourIdentityKey: Uint8Array
     private inviteUnsubscribes: Map<string, Unsubscribe> = new Map()
-    private ownDeviceInvites: Map<string, Invite | null> = new Map()
+    private deviceId: string
+    private invite?: Invite
+    private storage: StorageAdapter
+    private messageQueue: Map<string, Array<{event: Partial<Rumor>, resolve: (results: any[]) => void}>> = new Map()
 
-    constructor(ourIdentityKey: Uint8Array, nostrSubscribe: NostrSubscribe, nostrPublish: NostrPublish) {
+    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
+                
+                const targetUserKey = inviteePubkey
+                
+                try {
+                    let userRecord = this.userRecords.get(targetUserKey)
+                    if (!userRecord) {
+                        userRecord = new UserRecord(targetUserKey, this.nostrSubscribe)
+                        this.userRecords.set(targetUserKey, userRecord)
+                    }
+
+                    const deviceKey = session.name || 'unknown'
+                    userRecord.upsertSession(deviceKey, session)
+                    this.saveSession(targetUserKey, 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) {
@@ -27,32 +199,62 @@ export default class SessionManager {
     }
 
     async sendEvent(recipientIdentityKey: string, event: Partial<Rumor>) {
+        console.log("Sending event to", recipientIdentityKey, event)
+        // Immediately notify local subscribers so that UI can render sent message optimistically
+        this.internalSubscriptions.forEach(cb => cb(event as Rumor))
+
         const results = []
-        
+        const publishPromises: Promise<any>[] = []
+
         // Send to recipient's devices
         const userRecord = this.userRecords.get(recipientIdentityKey)
         if (!userRecord) {
-            // Listen for invites from recipient
-            this.listenToUser(recipientIdentityKey)
-            throw new Error("No active session with user. Listening for invites.")
+            return new Promise<any[]>((resolve) => {
+                if (!this.messageQueue.has(recipientIdentityKey)) {
+                    this.messageQueue.set(recipientIdentityKey, [])
+                }
+                this.messageQueue.get(recipientIdentityKey)!.push({event, resolve})
+                this.listenToUser(recipientIdentityKey)
+            })
+        }
+
+        const activeSessions = userRecord.getActiveSessions()
+        const sendableSessions = activeSessions.filter(s => !!(s.state?.theirNextNostrPublicKey && s.state?.ourCurrentNostrKey))
+        
+        if (sendableSessions.length === 0) {
+            return new Promise<any[]>((resolve) => {
+                if (!this.messageQueue.has(recipientIdentityKey)) {
+                    this.messageQueue.set(recipientIdentityKey, [])
+                }
+                this.messageQueue.get(recipientIdentityKey)!.push({event, resolve})
+                this.listenToUser(recipientIdentityKey)
+            })
         }
 
-        // Send to all active sessions with recipient
-        for (const session of userRecord.getActiveSessions()) {
+        // Send to all sendable sessions with recipient
+        for (const session of sendableSessions) {
             const { event: encryptedEvent } = session.sendEvent(event)
             results.push(encryptedEvent)
+            publishPromises.push(this.nostrPublish(encryptedEvent).catch(() => {}))
         }
 
         // 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 ownSendableSessions = ownUserRecord.getActiveSessions().filter(s => !!(s.state?.theirNextNostrPublicKey && s.state?.ourCurrentNostrKey))
+            for (const session of ownSendableSessions) {
                 const { event: encryptedEvent } = session.sendEvent(event)
                 results.push(encryptedEvent)
+                publishPromises.push(this.nostrPublish(encryptedEvent).catch(() => {}))
             }
         }
 
+        // Ensure all publish operations settled before returning
+        if (publishPromises.length > 0) {
+            await Promise.all(publishPromises)
+        }
+
         return results
     }
 
@@ -62,26 +264,53 @@ export default class SessionManager {
 
         const unsubscribe = Invite.fromUser(userPubkey, this.nostrSubscribe, async (_invite) => {
             try {
+                const deviceId = (_invite instanceof Invite && _invite.deviceId) ? _invite.deviceId : 'unknown'
+                
+                const userRecord = this.userRecords.get(userPubkey)
+                if (userRecord) {
+                    const existingSessions = userRecord.getActiveSessions()
+                    if (existingSessions.some(session => session.name === deviceId)) {
+                        return // Already have session with this device
+                    }
+                }
+
                 const { session, event } = await _invite.accept(
                     this.nostrSubscribe,
                     getPublicKey(this.ourIdentityKey),
                     this.ourIdentityKey
                 )
-                this.nostrPublish(event)
+                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)
+                let currentUserRecord = this.userRecords.get(userPubkey)
+                if (!currentUserRecord) {
+                    currentUserRecord = new UserRecord(userPubkey, this.nostrSubscribe)
+                    this.userRecords.set(userPubkey, currentUserRecord)
                 }
-                userRecord.insertSession(event.id || 'unknown', session)
+                currentUserRecord.upsertSession(deviceId, session)
+                this.saveSession(userPubkey, deviceId, session)
 
-                // Set up event handling for the new session
-                session.onEvent((_event) => {
+                // Register all existing callbacks on the new session
+                session.onEvent((_event: Rumor) => {
                     this.internalSubscriptions.forEach(callback => callback(_event))
                 })
 
+                const queuedMessages = this.messageQueue.get(userPubkey)
+                if (queuedMessages && queuedMessages.length > 0) {
+                    setTimeout(async () => {
+                        const currentQueuedMessages = this.messageQueue.get(userPubkey)
+                        if (currentQueuedMessages && currentQueuedMessages.length > 0) {
+                            const messagesToProcess = [...currentQueuedMessages]
+                            this.messageQueue.delete(userPubkey)
+                            
+                            for (const {event: queuedEvent, resolve} of messagesToProcess) {
+                                const results = await this.sendEvent(userPubkey, queuedEvent)
+                                resolve(results)
+                            }
+                        }
+                    }, 1000) // Increased delay for CI compatibility
+                }
+
                 // Return the event to be published
                 return event
             } catch {
@@ -100,9 +329,9 @@ export default class SessionManager {
     }
 
     // Update onEvent to include internalSubscriptions management
-    private internalSubscriptions: Set<(_event: Rumor) => void> = new Set()
+    private internalSubscriptions: Set<(event: Rumor) => void> = new Set()
 
-    onEvent(callback: (_event: Rumor) => void) {
+    onEvent(callback: (event: Rumor) => void) {
         this.internalSubscriptions.add(callback)
 
         // Subscribe to existing sessions
@@ -135,31 +364,26 @@ export default class SessionManager {
         }
         this.userRecords.clear()
         this.internalSubscriptions.clear()
-        this.ownDeviceInvites.clear()
-    }
-
-    createOwnDeviceInvite(deviceName: string, label?: string, maxUses?: number): Invite {
-        const ourPublicKey = getPublicKey(this.ourIdentityKey)
-        const invite = Invite.createNew(ourPublicKey, label, maxUses)
-        this.ownDeviceInvites.set(deviceName, invite)
-        return invite
-    }
-
-    removeOwnDevice(deviceName: string): void {
-        this.ownDeviceInvites.set(deviceName, null)
-    }
-
-    getOwnDeviceInvites(): Map<string, Invite | null> {
-        return new Map(this.ownDeviceInvites)
     }
 
-    getActiveOwnDeviceInvites(): Map<string, Invite> {
-        const active = new Map<string, Invite>()
-        for (const [deviceName, invite] of this.ownDeviceInvites) {
-            if (invite !== null) {
-                active.set(deviceName, invite)
-            }
+    /**
+     * 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);
         }
-        return active
+        userRecord.upsertSession(session.name || 'unknown', session);
+        await this.saveSession(ourPublicKey, session.name || 'unknown', session);
+        this.nostrPublish(event)?.catch(() => {});
     }
 }

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
+  }
+}