nostr-double-ratchet 0.0.37 → 0.0.48

package/src/SessionManager.ts

@@ -1,46 +1,60 @@
 import {
-  DecryptFunction,
+  IdentityKey,
   NostrSubscribe,
   NostrPublish,
   Rumor,
   Unsubscribe,
-  INVITE_EVENT_KIND,
+  APP_KEYS_EVENT_KIND,
   CHAT_MESSAGE_KIND,
 } from "./types"
 import { StorageAdapter, InMemoryStorageAdapter } from "./StorageAdapter"
+import { AppKeys, DeviceEntry } from "./AppKeys"
 import { Invite } from "./Invite"
 import { Session } from "./Session"
 import { serializeSessionState, deserializeSessionState } from "./utils"
-import { getEventHash, VerifiedEvent } from "nostr-tools"
+import { decryptInviteResponse, createSessionFromAccept } from "./inviteUtils"
+import { getEventHash } from "nostr-tools"
 
 export type OnEventCallback = (event: Rumor, from: string) => void
 
-interface DeviceRecord {
+/**
+ * Credentials for the invite handshake - used to listen for and decrypt invite responses
+ */
+export interface InviteCredentials {
+  ephemeralKeypair: { publicKey: string; privateKey: Uint8Array }
+  sharedSecret: string
+}
+
+export interface DeviceRecord {
   deviceId: string
   activeSession?: Session
   inactiveSessions: Session[]
   createdAt: number
-  staleAt?: number
 }
 
-interface UserRecord {
+export interface UserRecord {
   publicKey: string
   devices: Map<string, DeviceRecord>
+  /** Device identity pubkeys from AppKeys - used to rebuild delegateToOwner on load */
+  knownDeviceIdentities: string[]
 }
 
-type StoredSessionEntry = ReturnType<typeof serializeSessionState>
+interface StoredSessionEntry {
+  name: string
+  state: string
+}
 
 interface StoredDeviceRecord {
   deviceId: string
   activeSession: StoredSessionEntry | null
   inactiveSessions: StoredSessionEntry[]
   createdAt: number
-  staleAt?: number
 }
 
 interface StoredUserRecord {
   publicKey: string
   devices: StoredDeviceRecord[]
+  knownDeviceIdentities?: string[]
 }
 
 export class SessionManager {
@@ -53,20 +67,26 @@ export class SessionManager {
   private storage: StorageAdapter
   private nostrSubscribe: NostrSubscribe
   private nostrPublish: NostrPublish
-  private ourIdentityKey: Uint8Array | DecryptFunction
+  private identityKey: IdentityKey
   private ourPublicKey: string
+  // Owner's public key - used for grouping devices together (all devices are delegates)
+  private ownerPublicKey: string
+
+  // Credentials for invite handshake
+  private inviteKeys: InviteCredentials
 
   // Data
   private userRecords: Map<string, UserRecord> = new Map()
   private messageHistory: Map<string, Rumor[]> = new Map()
-  private currentDeviceInvite: Invite | null = null
+  // Map delegate device pubkeys to their owner's pubkey
+  private delegateToOwner: Map<string, string> = new Map()
+  // Track processed InviteResponse event IDs to prevent replay
+  private processedInviteResponses: Set<string> = new Set()
 
   // Subscriptions
-  private ourDeviceInviteSubscription: Unsubscribe | null = null
-  private ourDeviceIntiveTombstoneSubscription: Unsubscribe | null = null
+  private ourInviteResponseSubscription: Unsubscribe | null = null
   private inviteSubscriptions: Map<string, Unsubscribe> = new Map()
   private sessionSubscriptions: Map<string, Unsubscribe> = new Map()
-  private inviteTombstoneSubscriptions: Map<string, Unsubscribe> = new Map()
 
   // Callbacks
   private internalSubscriptions: Set<OnEventCallback> = new Set()
@@ -76,18 +96,22 @@ export class SessionManager {
 
   constructor(
     ourPublicKey: string,
-    ourIdentityKey: Uint8Array | DecryptFunction,
+    identityKey: IdentityKey,
     deviceId: string,
     nostrSubscribe: NostrSubscribe,
     nostrPublish: NostrPublish,
-    storage?: StorageAdapter
+    ownerPublicKey: string,
+    inviteKeys: InviteCredentials,
+    storage?: StorageAdapter,
   ) {
     this.userRecords = new Map()
     this.nostrSubscribe = nostrSubscribe
     this.nostrPublish = nostrPublish
     this.ourPublicKey = ourPublicKey
-    this.ourIdentityKey = ourIdentityKey
+    this.identityKey = identityKey
     this.deviceId = deviceId
+    this.ownerPublicKey = ownerPublicKey
+    this.inviteKeys = inviteKeys
     this.storage = storage || new InMemoryStorageAdapter()
     this.versionPrefix = `v${this.storageVersion}`
   }
@@ -96,62 +120,155 @@ export class SessionManager {
     if (this.initialized) return
     this.initialized = true
 
-    await this.runMigrations().catch((error) => {
-      console.error("Failed to run migrations:", error)
+    await this.runMigrations().catch(() => {
+      // Failed to run migrations
     })
 
-    await this.loadAllUserRecords().catch((error) => {
-      console.error("Failed to load user records:", error)
+    await this.loadAllUserRecords().catch(() => {
+      // Failed to load user records
     })
 
-    const ourInviteFromStorage: Invite | null = await this.storage
-      .get<string>(this.deviceInviteKey(this.deviceId))
-      .then((data) => {
-        if (!data) return null
-        try {
-          return Invite.deserialize(data)
-        } catch {
-          return null
+    // Add our own device to user record to prevent accepting our own invite
+    // Use ownerPublicKey so delegates are added to the owner's record
+    const ourUserRecord = this.getOrCreateUserRecord(this.ownerPublicKey)
+    this.upsertDeviceRecord(ourUserRecord, this.deviceId)
+
+    // Start invite response listener BEFORE setting up users
+    // This ensures we're listening when other devices respond to our invites
+    this.startInviteResponseListener()
+    // Setup sessions with our own other devices
+    // Use ownerPublicKey to find sibling devices (important for delegates)
+    this.setupUser(this.ownerPublicKey)
+  }
+
+  /**
+   * Start listening for invite responses on our ephemeral key.
+   * This is used by devices to receive session establishment responses.
+   */
+  private startInviteResponseListener(): void {
+    const { publicKey: ephemeralPubkey, privateKey: ephemeralPrivkey } = this.inviteKeys.ephemeralKeypair
+    const sharedSecret = this.inviteKeys.sharedSecret
+
+    // Subscribe to invite responses tagged to our ephemeral key
+    this.ourInviteResponseSubscription = this.nostrSubscribe(
+      {
+        kinds: [1059], // INVITE_RESPONSE_KIND
+        "#p": [ephemeralPubkey],
+      },
+      async (event) => {
+        // Skip already processed InviteResponses (prevents replay issues on restart)
+        if (this.processedInviteResponses.has(event.id)) {
+          return
         }
-      })
+        this.processedInviteResponses.add(event.id)
 
-    const invite =
-      ourInviteFromStorage || Invite.createNew(this.ourPublicKey, this.deviceId)
-
-    this.currentDeviceInvite = invite
-
-    await this.storage.put(this.deviceInviteKey(this.deviceId), invite.serialize())
+        try {
+          const decrypted = await decryptInviteResponse({
+            envelopeContent: event.content,
+            envelopeSenderPubkey: event.pubkey,
+            inviterEphemeralPrivateKey: ephemeralPrivkey,
+            inviterPrivateKey: this.identityKey instanceof Uint8Array ? this.identityKey : undefined,
+            sharedSecret,
+            decrypt: this.identityKey instanceof Uint8Array ? undefined : this.identityKey.decrypt,
+          })
+
+          // Skip our own responses - this happens when we publish an invite response
+          // and our own listener receives it back from relays
+          // inviteeIdentity serves as the device ID
+          if (decrypted.inviteeIdentity === this.deviceId) {
+            return
+          }
 
-    this.ourDeviceInviteSubscription = invite.listen(
-      this.ourIdentityKey,
-      this.nostrSubscribe,
-      async (session, inviteePubkey, deviceId) => {
-        if (!deviceId || deviceId === this.deviceId) return
-        const nostrEventId = session.name
-        const acceptanceKey = this.inviteAcceptKey(nostrEventId, inviteePubkey, deviceId)
-        const nostrEventIdInStorage = await this.storage.get<string>(acceptanceKey)
-        if (nostrEventIdInStorage) {
-          return
-        }
+          // Get owner pubkey from response (required for proper chat routing)
+          // If not present (old client), fall back to resolveToOwner
+          const claimedOwner = decrypted.ownerPublicKey || this.resolveToOwner(decrypted.inviteeIdentity)
 
-        await this.storage.put(acceptanceKey, "1")
+          // Verify the device is authorized by fetching owner's AppKeys
+          const appKeys = await this.fetchAppKeys(claimedOwner)
 
-        const userRecord = this.getOrCreateUserRecord(inviteePubkey)
-        const deviceRecord = this.upsertDeviceRecord(userRecord, deviceId)
+          if (appKeys) {
+            const deviceInList = appKeys.getAllDevices().some(
+              d => d.identityPubkey === decrypted.inviteeIdentity
+            )
+            if (!deviceInList) {
+              return
+            }
+            this.updateDelegateMapping(claimedOwner, appKeys)
+          } else {
+            // No AppKeys - check cached identities or single-device case
+            const cachedIdentities = this.userRecords.get(claimedOwner)?.knownDeviceIdentities || []
+            const isCached = cachedIdentities.includes(decrypted.inviteeIdentity)
+            const isSingleDevice = decrypted.inviteeIdentity === claimedOwner
+            if (!isCached && !isSingleDevice) {
+              return
+            }
+          }
 
-        this.attachSessionSubscription(inviteePubkey, deviceRecord, session, true)
+          const ownerPubkey = claimedOwner
+          const userRecord = this.getOrCreateUserRecord(ownerPubkey)
+          // inviteeIdentity serves as the device ID
+          const deviceRecord = this.upsertDeviceRecord(userRecord, decrypted.inviteeIdentity)
+
+          const session = createSessionFromAccept({
+            nostrSubscribe: this.nostrSubscribe,
+            theirPublicKey: decrypted.inviteeSessionPublicKey,
+            ourSessionPrivateKey: ephemeralPrivkey,
+            sharedSecret,
+            isSender: false,
+            name: event.id,
+          })
+
+          this.attachSessionSubscription(ownerPubkey, deviceRecord, session, true)
+          this.storeUserRecord(ownerPubkey).catch(() => {})
+        } catch {
+        }
       }
     )
+  }
 
-    if (!this.ourDeviceIntiveTombstoneSubscription) {
-      this.ourDeviceIntiveTombstoneSubscription = this.createInviteTombstoneSubscription(
-        this.ourPublicKey
-      )
-    }
+  /**
+   * Fetch a user's AppKeys from relays.
+   * Returns null if not found within timeout.
+   */
+  private fetchAppKeys(pubkey: string, timeoutMs = 2000): Promise<AppKeys | null> {
+    return new Promise((resolve) => {
+      let latestEvent: { created_at: number; appKeys: AppKeys } | null = null
+      let resolved = false
+
+      // Use a short initial delay before resolving to allow event delivery
+      const resolveResult = () => {
+        if (resolved) return
+        resolved = true
+        unsubscribe()
+        resolve(latestEvent?.appKeys ?? null)
+      }
 
-    const inviteNostrEvent = invite.getEvent()
-    this.nostrPublish(inviteNostrEvent).catch((error) => {
-      console.error("Failed to publish our device invite:", error)
+      // Start timeout
+      const timeout = setTimeout(resolveResult, timeoutMs)
+
+      const unsubscribe = this.nostrSubscribe(
+        {
+          kinds: [APP_KEYS_EVENT_KIND],
+          authors: [pubkey],
+          "#d": ["double-ratchet/app-keys"],
+        },
+        (event) => {
+          if (resolved) return
+          try {
+            const appKeys = AppKeys.fromEvent(event)
+            // Use >= to prefer later-delivered events when timestamps are equal
+            // This handles replaceable events created within the same second
+            if (!latestEvent || event.created_at >= latestEvent.created_at) {
+              latestEvent = { created_at: event.created_at, appKeys }
+            }
+            // Resolve quickly after receiving an event (allow for more events to arrive)
+            clearTimeout(timeout)
+            setTimeout(resolveResult, 100) // Short delay to collect any late events
+          } catch {
+            // Invalid event, ignore
+          }
+        }
+      )
     })
   }
 
@@ -161,7 +278,7 @@ export class SessionManager {
   private getOrCreateUserRecord(userPubkey: string): UserRecord {
     let rec = this.userRecords.get(userPubkey)
     if (!rec) {
-      rec = { publicKey: userPubkey, devices: new Map() }
+      rec = { publicKey: userPubkey, devices: new Map(), knownDeviceIdentities: [] }
       this.userRecords.set(userPubkey, rec)
     }
     return rec
@@ -185,56 +302,9 @@ export class SessionManager {
     return deviceRecord
   }
 
-  private createInviteTombstoneSubscription(authorPublicKey: string): Unsubscribe {
-    return this.nostrSubscribe(
-      {
-        kinds: [INVITE_EVENT_KIND],
-        authors: [authorPublicKey],
-        "#l": ["double-ratchet/invites"],
-      },
-      (event: VerifiedEvent) => {
-        try {
-          const isTombstone = !event.tags?.some(
-            ([key]) => key === "ephemeralKey" || key === "sharedSecret"
-          )
-          if (isTombstone) {
-            const deviceIdTag = event.tags.find(
-              ([key, value]) => key === "d" && value.startsWith("double-ratchet/invites/")
-            )
-            const [, deviceIdTagValue] = deviceIdTag || []
-            const deviceId = deviceIdTagValue.split("/").pop()
-            if (!deviceId) return
-
-            this.cleanupDevice(authorPublicKey, deviceId)
-          }
-        } catch (error) {
-          console.error("Failed to handle device tombstone:", error)
-        }
-      }
-    )
-  }
-
   private sessionKey(userPubkey: string, deviceId: string, sessionName: string) {
     return `${this.sessionKeyPrefix(userPubkey)}${deviceId}/${sessionName}`
   }
-  private inviteKey(userPubkey: string) {
-    return this.userInviteKey(userPubkey)
-  }
-  private inviteAcceptKey(nostrEventId: string, userPubkey: string, deviceId: string) {
-    return `${this.inviteAcceptKeyPrefix(userPubkey)}${deviceId}/${nostrEventId}`
-  }
-
-  private deviceInviteKey(deviceId: string) {
-    return `${this.versionPrefix}/device-invite/${deviceId}`
-  }
-
-  private userInviteKey(userPubkey: string) {
-    return `${this.versionPrefix}/invite/${userPubkey}`
-  }
-
-  private inviteAcceptKeyPrefix(userPublicKey: string) {
-    return `${this.versionPrefix}/invite-accept/${userPublicKey}/`
-  }
 
   private sessionKeyPrefix(userPubkey: string) {
     return `${this.versionPrefix}/session/${userPubkey}/`
@@ -251,6 +321,62 @@ export class SessionManager {
     return `storage-version`
   }
 
+  /**
+   * Resolve a pubkey to its owner if it's a known delegate device.
+   * Returns the input pubkey if not a known delegate.
+   */
+  private resolveToOwner(pubkey: string): string {
+    return this.delegateToOwner.get(pubkey) || pubkey
+  }
+
+  /**
+   * Update the delegate-to-owner mapping from an AppKeys.
+   * Extracts delegate device pubkeys and maps them to the owner.
+   * Persists the mapping in the user record for restart recovery.
+   */
+  private updateDelegateMapping(ownerPubkey: string, appKeys: AppKeys): void {
+    const userRecord = this.getOrCreateUserRecord(ownerPubkey)
+    const deviceIdentities = appKeys.getAllDevices()
+      .map(d => d.identityPubkey)
+      .filter(Boolean) as string[]
+
+    // Update user record with known device identities
+    userRecord.knownDeviceIdentities = deviceIdentities
+
+    // Update in-memory mapping
+    for (const identity of deviceIdentities) {
+      this.delegateToOwner.set(identity, ownerPubkey)
+    }
+
+    // Persist
+    this.storeUserRecord(ownerPubkey).catch(() => {})
+  }
+
+  private subscribeToUserAppKeys(
+    pubkey: string,
+    onAppKeys: (list: AppKeys) => void
+  ): Unsubscribe {
+    return this.nostrSubscribe(
+      {
+        kinds: [APP_KEYS_EVENT_KIND],
+        authors: [pubkey],
+        "#d": ["double-ratchet/app-keys"],
+      },
+      (event) => {
+        try {
+          const list = AppKeys.fromEvent(event)
+          // Update delegate mapping whenever we receive an AppKeys
+          this.updateDelegateMapping(pubkey, list)
+          onAppKeys(list)
+        } catch {
+          // Invalid event, ignore
+        }
+      }
+    )
+  }
+
+  private static MAX_INACTIVE_SESSIONS = 10
+
   private attachSessionSubscription(
     userPubkey: string,
     deviceRecord: DeviceRecord,
@@ -258,111 +384,212 @@ export class SessionManager {
     // Set to true if only handshake -> not yet sendable -> will be promoted on message
     inactive: boolean = false
   ): void {
-    if (deviceRecord.staleAt !== undefined) return
-
     const key = this.sessionKey(userPubkey, deviceRecord.deviceId, session.name)
-    if (this.sessionSubscriptions.has(key)) return
+    if (this.sessionSubscriptions.has(key)) {
+      return
+    }
 
     const dr = deviceRecord
-    const rotateSession = (nextSession: Session) => {
-      const current = dr.activeSession
 
-      if (!current) {
-        dr.activeSession = nextSession
-        return
-      }
+    // Promote a session to active when it receives a message
+    // Current active goes to top of inactive queue
+    const promoteToActive = (nextSession: Session) => {
+      const current = dr.activeSession
 
-      if (current === nextSession || current.name === nextSession.name) {
-        dr.activeSession = nextSession
+      // Already active, nothing to do
+      if (current === nextSession || current?.name === nextSession.name) {
         return
       }
 
+      // Remove nextSession from inactive if present
       dr.inactiveSessions = dr.inactiveSessions.filter(
-        (session) => session !== current && session.name !== current.name
+        (s) => s !== nextSession && s.name !== nextSession.name
       )
 
-      dr.inactiveSessions.push(current)
-      dr.inactiveSessions = dr.inactiveSessions.slice(-1)
+      // Move current active to top of inactive queue
+      if (current) {
+        dr.inactiveSessions.unshift(current)
+      }
+
+      // Set new active
       dr.activeSession = nextSession
+
+      // Trim inactive queue to max size (remove oldest from end)
+      if (dr.inactiveSessions.length > SessionManager.MAX_INACTIVE_SESSIONS) {
+        const removed = dr.inactiveSessions.splice(SessionManager.MAX_INACTIVE_SESSIONS)
+        // Unsubscribe from removed sessions
+        for (const s of removed) {
+          this.removeSessionSubscription(userPubkey, dr.deviceId, s.name)
+        }
+      }
     }
 
+    // Add new session: if inactive, add to top of inactive queue; otherwise set as active
     if (inactive) {
       const alreadyTracked = dr.inactiveSessions.some(
-        (tracked) => tracked === session || tracked.name === session.name
+        (s) => s === session || s.name === session.name
       )
       if (!alreadyTracked) {
-        dr.inactiveSessions.push(session)
-        dr.inactiveSessions = dr.inactiveSessions.slice(-1)
+        // Add to top of inactive queue
+        dr.inactiveSessions.unshift(session)
+        // Trim to max size
+        if (dr.inactiveSessions.length > SessionManager.MAX_INACTIVE_SESSIONS) {
+          const removed = dr.inactiveSessions.splice(SessionManager.MAX_INACTIVE_SESSIONS)
+          for (const s of removed) {
+            this.removeSessionSubscription(userPubkey, dr.deviceId, s.name)
+          }
+        }
       }
     } else {
-      rotateSession(session)
+      promoteToActive(session)
     }
 
+    // Subscribe to session events - when message received, promote to active
     const unsub = session.onEvent((event) => {
       for (const cb of this.internalSubscriptions) cb(event, userPubkey)
-      rotateSession(session)
-      this.storeUserRecord(userPubkey).catch(console.error)
+      promoteToActive(session)
+      this.storeUserRecord(userPubkey).catch(() => {})
     })
-    this.storeUserRecord(userPubkey).catch(console.error)
+    this.storeUserRecord(userPubkey).catch(() => {})
     this.sessionSubscriptions.set(key, unsub)
   }
 
-  private attachInviteSubscription(
+  private attachAppKeysSubscription(
     userPubkey: string,
-    onInvite?: (invite: Invite) => void | Promise<void>
+    onAppKeys?: (appKeys: AppKeys) => void | Promise<void>
   ): void {
-    const key = this.inviteKey(userPubkey)
+    const key = `appkeys:${userPubkey}`
     if (this.inviteSubscriptions.has(key)) return
 
-    const unsubscribe = Invite.fromUser(
+    const unsubscribe = this.subscribeToUserAppKeys(
       userPubkey,
-      this.nostrSubscribe,
-      async (invite) => {
-        if (!invite.deviceId) return
-        if (onInvite) await onInvite(invite)
+      async (appKeys) => {
+        if (onAppKeys) await onAppKeys(appKeys)
       }
     )
 
     this.inviteSubscriptions.set(key, unsubscribe)
   }
 
-  private attachInviteTombstoneSubscription(userPubkey: string): void {
-    if (this.inviteTombstoneSubscriptions.has(userPubkey)) {
-      return
-    }
-
-    const unsubscribe = this.createInviteTombstoneSubscription(userPubkey)
-    this.inviteTombstoneSubscriptions.set(userPubkey, unsubscribe)
-  }
-
   setupUser(userPubkey: string) {
     const userRecord = this.getOrCreateUserRecord(userPubkey)
 
-    this.attachInviteTombstoneSubscription(userPubkey)
+    // Track which device identities we've subscribed to for invites
+    const subscribedDeviceIdentities = new Set<string>()
+    // Track devices currently being accepted (to prevent duplicate acceptance)
+    const pendingAcceptances = new Set<string>()
+
+    /**
+     * Accept an invite from a device.
+     * The invite is fetched separately from the device's own Invite event.
+     */
+    const acceptInviteFromDevice = async (
+      device: DeviceEntry,
+      invite: Invite
+    ) => {
+      // Double-check for active session (race condition guard)
+      // Another concurrent call may have already established a session
+      const existingRecord = userRecord.devices.get(device.identityPubkey)
+      if (existingRecord?.activeSession) {
+        return
+      }
 
-    const acceptInvite = async (invite: Invite) => {
-      const { deviceId } = invite
-      if (!deviceId) return
+      // Add device record IMMEDIATELY to prevent duplicate acceptance from race conditions
+      // Use identityPubkey as the device identifier
+      const deviceRecord = this.upsertDeviceRecord(userRecord, device.identityPubkey)
 
+      const encryptor = this.identityKey instanceof Uint8Array ? this.identityKey : this.identityKey.encrypt
+      // ourPublicKey serves as both identity and device ID
       const { session, event } = await invite.accept(
         this.nostrSubscribe,
         this.ourPublicKey,
-        this.ourIdentityKey,
-        this.deviceId
+        encryptor,
+        this.ownerPublicKey
       )
       return this.nostrPublish(event)
-        .then(() => this.upsertDeviceRecord(userRecord, deviceId))
-        .then((dr) => this.attachSessionSubscription(userPubkey, dr, session))
-        .then(() => this.sendMessageHistory(userPubkey, deviceId))
-        .catch(console.error)
+        .then(() => {
+          this.attachSessionSubscription(userPubkey, deviceRecord, session)
+        })
+        .then(() => this.sendMessageHistory(userPubkey, device.identityPubkey))
+        .catch(() => {})
+    }
+
+    /**
+     * Subscribe to a device's Invite event and accept it when received.
+     */
+    const subscribeToDeviceInvite = (device: DeviceEntry) => {
+      // identityPubkey is the device identifier
+      const deviceKey = device.identityPubkey
+      if (subscribedDeviceIdentities.has(deviceKey)) {
+        return
+      }
+      subscribedDeviceIdentities.add(deviceKey)
+
+      // Already have a record with active session for this device? Skip.
+      const existingRecord = userRecord.devices.get(device.identityPubkey)
+      if (existingRecord?.activeSession) {
+        return
+      }
+
+      const inviteSubKey = `invite:${device.identityPubkey}`
+      if (this.inviteSubscriptions.has(inviteSubKey)) {
+        return
+      }
+
+      // Subscribe to this device's Invite event
+      const unsub = Invite.fromUser(device.identityPubkey, this.nostrSubscribe, async (invite) => {
+        // Verify the invite is for this device (identityPubkey is the device identifier)
+        if (invite.deviceId !== device.identityPubkey) {
+          return
+        }
+
+        // Skip if we already have an active session (race condition guard)
+        const existingDeviceRecord = userRecord.devices.get(device.identityPubkey)
+        if (existingDeviceRecord?.activeSession) {
+          return
+        }
+
+        // Skip if acceptance is already in progress (race condition guard)
+        if (pendingAcceptances.has(device.identityPubkey)) {
+          return
+        }
+
+        pendingAcceptances.add(device.identityPubkey)
+        try {
+          await acceptInviteFromDevice(device, invite)
+        } finally {
+          pendingAcceptances.delete(device.identityPubkey)
+        }
+      })
+
+      this.inviteSubscriptions.set(inviteSubKey, unsub)
     }
 
-    this.attachInviteSubscription(userPubkey, async (invite) => {
-      const { deviceId } = invite
-      if (!deviceId) return
+    this.attachAppKeysSubscription(userPubkey, async (appKeys) => {
+      const devices = appKeys.getAllDevices()
+      const activeDeviceIds = new Set(devices.map(d => d.identityPubkey))
+
+      // Handle devices no longer in list (revoked or AppKeys recreated from scratch)
+      const userRecord = this.userRecords.get(userPubkey)
+      if (userRecord) {
+        for (const [deviceId] of userRecord.devices) {
+          if (!activeDeviceIds.has(deviceId)) {
+            // Remove from tracking so device can be re-subscribed if re-added
+            subscribedDeviceIdentities.delete(deviceId)
+            const inviteSubKey = `invite:${deviceId}`
+            const inviteUnsub = this.inviteSubscriptions.get(inviteSubKey)
+            if (inviteUnsub) {
+              inviteUnsub()
+              this.inviteSubscriptions.delete(inviteSubKey)
+            }
+            await this.cleanupDevice(userPubkey, deviceId)
+          }
+        }
+      }
 
-      if (!userRecord.devices.has(deviceId)) {
-        await acceptInvite(invite)
+      // For each device in AppKeys, subscribe to their Invite event
+      for (const device of devices) {
+        subscribeToDeviceInvite(device)
       }
     })
   }
@@ -379,10 +606,6 @@ export class SessionManager {
     return this.deviceId
   }
 
-  getDeviceInviteEphemeralKey(): string | null {
-    return this.currentDeviceInvite?.inviterEphemeralPublicKey || null
-  }
-
   getUserRecords(): Map<string, UserRecord> {
     return this.userRecords
   }
@@ -396,12 +619,7 @@ export class SessionManager {
       unsubscribe()
     }
 
-    for (const unsubscribe of this.inviteTombstoneSubscriptions.values()) {
-      unsubscribe()
-    }
-
-    this.ourDeviceInviteSubscription?.()
-    this.ourDeviceIntiveTombstoneSubscription?.()
+    this.ourInviteResponseSubscription?.()
   }
 
   deactivateCurrentSessions(publicKey: string) {
@@ -413,7 +631,7 @@ export class SessionManager {
         device.activeSession = undefined
       }
     }
-    this.storeUserRecord(publicKey).catch(console.error)
+    this.storeUserRecord(publicKey).catch(() => {})
   }
 
   async deleteUser(userPubkey: string): Promise<void> {
@@ -439,23 +657,16 @@ export class SessionManager {
       this.userRecords.delete(userPubkey)
     }
 
-    const inviteKey = this.inviteKey(userPubkey)
-    const inviteUnsub = this.inviteSubscriptions.get(inviteKey)
-    if (inviteUnsub) {
-      inviteUnsub()
-      this.inviteSubscriptions.delete(inviteKey)
-    }
-
-    const tombstoneUnsub = this.inviteTombstoneSubscriptions.get(userPubkey)
-    if (tombstoneUnsub) {
-      tombstoneUnsub()
-      this.inviteTombstoneSubscriptions.delete(userPubkey)
+    const appKeysKey = `appkeys:${userPubkey}`
+    const appKeysUnsub = this.inviteSubscriptions.get(appKeysKey)
+    if (appKeysUnsub) {
+      appKeysUnsub()
+      this.inviteSubscriptions.delete(appKeysKey)
     }
 
     this.messageHistory.delete(userPubkey)
 
     await Promise.allSettled([
-      this.storage.del(this.inviteKey(userPubkey)),
       this.deleteUserSessionsFromStorage(userPubkey),
       this.storage.del(this.userRecordKey(userPubkey)),
     ])
@@ -493,13 +704,12 @@ export class SessionManager {
     if (!device) {
       return
     }
-    if (device.staleAt !== undefined) {
-      return
-    }
     for (const event of history) {
       const { activeSession } = device
 
-      if (!activeSession) continue
+      if (!activeSession) {
+        continue
+      }
       const { event: verifiedEvent } = activeSession.sendEvent(event)
       await this.nostrPublish(verifiedEvent)
       await this.storeUserRecord(recipientPublicKey)
@@ -514,36 +724,56 @@ export class SessionManager {
 
     // Add to message history queue (will be sent when session is established)
     const completeEvent = event as Rumor
-    const historyTargets = new Set([recipientIdentityKey, this.ourPublicKey])
+    // Use ownerPublicKey for history targets so delegates share history with owner
+    const historyTargets = new Set([recipientIdentityKey, this.ownerPublicKey])
     for (const key of historyTargets) {
       const existing = this.messageHistory.get(key) || []
       this.messageHistory.set(key, [...existing, completeEvent])
     }
 
     const userRecord = this.getOrCreateUserRecord(recipientIdentityKey)
-    const ourUserRecord = this.getOrCreateUserRecord(this.ourPublicKey)
+    // Use ownerPublicKey to find sibling devices (important for delegates)
+    const ourUserRecord = this.getOrCreateUserRecord(this.ownerPublicKey)
 
     this.setupUser(recipientIdentityKey)
-    this.setupUser(this.ourPublicKey)
-
-    const devices = [
-      ...Array.from(userRecord.devices.values()),
-      ...Array.from(ourUserRecord.devices.values()),
-    ].filter((device) => device.staleAt === undefined)
+    // Use ownerPublicKey to setup sessions with sibling devices
+    this.setupUser(this.ownerPublicKey)
+
+    const recipientDevices = Array.from(userRecord.devices.values())
+    const ownDevices = Array.from(ourUserRecord.devices.values())
+
+    // Merge and deduplicate by deviceId, excluding our own sending device
+    // This fixes the self-message bug where sending to yourself would duplicate devices
+    const deviceMap = new Map<string, DeviceRecord>()
+    for (const d of [...recipientDevices, ...ownDevices]) {
+      if (d.deviceId !== this.deviceId) {  // Exclude sender's own device
+        deviceMap.set(d.deviceId, d)
+      }
+    }
+    const devices = Array.from(deviceMap.values())
 
-    // Send to all devices in background (if sessions exist)
-    Promise.allSettled(
+    // Send to all devices and await completion before returning
+    // This ensures session state is ratcheted and persisted before function returns
+    await Promise.allSettled(
       devices.map(async (device) => {
         const { activeSession } = device
-        if (!activeSession) return
+        if (!activeSession) {
+          return
+        }
         const { event: verifiedEvent } = activeSession.sendEvent(event)
-        await this.nostrPublish(verifiedEvent).catch(console.error)
+        await this.nostrPublish(verifiedEvent).catch(() => {})
       })
     )
-      .then(() => {
-        this.storeUserRecord(recipientIdentityKey)
-      })
-      .catch(console.error)
+
+    // Store recipient's user record after all messages sent
+    await this.storeUserRecord(recipientIdentityKey)
+    // Also store owner's record if different (for sibling device sessions)
+    // This ensures session state is persisted after ratcheting for both:
+    // - recipientDevices stored under recipientIdentityKey
+    // - Own sibling devices stored under ownerPublicKey
+    if (this.ownerPublicKey !== recipientIdentityKey) {
+      await this.storeUserRecord(this.ownerPublicKey)
+    }
 
     // Return the event with computed ID (same as library would compute)
     return completeEvent
@@ -576,58 +806,30 @@ export class SessionManager {
     rumor.id = getEventHash(rumor)
 
     // Use sendEvent for actual sending (includes queueing)
-    this.sendEvent(recipientPublicKey, rumor).catch(console.error)
+    // Note: sendEvent is not awaited to maintain backward compatibility
+    // The message is queued and will be sent when sessions are established
+    this.sendEvent(recipientPublicKey, rumor).catch(() => {})
 
     return rumor
   }
 
-  async revokeDevice(deviceId: string): Promise<void> {
-    await this.init()
-
-    await this.publishDeviceTombstone(deviceId).catch((error) => {
-      console.error("Failed to publish device tombstone:", error)
-    })
-
-    await this.cleanupDevice(this.ourPublicKey, deviceId)
-  }
-
-  private async publishDeviceTombstone(deviceId: string): Promise<void> {
-    const tags: string[][] = [
-      ["l", "double-ratchet/invites"],
-      ["d", `double-ratchet/invites/${deviceId}`],
-    ]
-
-    const deletionEvent = {
-      content: "",
-      kind: INVITE_EVENT_KIND,
-      created_at: Math.floor(Date.now() / 1000),
-      tags,
-      pubkey: this.ourPublicKey,
-    }
-
-    await this.nostrPublish(deletionEvent)
-  }
-
   private async cleanupDevice(publicKey: string, deviceId: string): Promise<void> {
     const userRecord = this.userRecords.get(publicKey)
     if (!userRecord) return
     const deviceRecord = userRecord.devices.get(deviceId)
-
     if (!deviceRecord) return
 
+    // Unsubscribe from sessions
     if (deviceRecord.activeSession) {
       this.removeSessionSubscription(publicKey, deviceId, deviceRecord.activeSession.name)
     }
-
     for (const session of deviceRecord.inactiveSessions) {
       this.removeSessionSubscription(publicKey, deviceId, session.name)
     }
 
-    deviceRecord.activeSession = undefined
-    deviceRecord.inactiveSessions = []
-    deviceRecord.staleAt = Date.now()
-
-    await this.storeUserRecord(publicKey).catch(console.error)
+    // Delete the device record entirely
+    userRecord.devices.delete(deviceId)
+    await this.storeUserRecord(publicKey).catch(() => {})
   }
 
   private buildMessageTags(
@@ -644,21 +846,26 @@ export class SessionManager {
   }
 
   private storeUserRecord(publicKey: string) {
+    const userRecord = this.userRecords.get(publicKey)
+    const devices = Array.from(userRecord?.devices.entries() || [])
+    const serializeSession = (session: Session): StoredSessionEntry => ({
+      name: session.name,
+      state: serializeSessionState(session.state)
+    })
+
     const data: StoredUserRecord = {
       publicKey: publicKey,
-      devices: Array.from(this.userRecords.get(publicKey)?.devices.entries() || []).map(
+      devices: devices.map(
         ([, device]) => ({
           deviceId: device.deviceId,
           activeSession: device.activeSession
-            ? serializeSessionState(device.activeSession.state)
+            ? serializeSession(device.activeSession)
             : null,
-          inactiveSessions: device.inactiveSessions.map((session) =>
-            serializeSessionState(session.state)
-          ),
+          inactiveSessions: device.inactiveSessions.map(serializeSession),
           createdAt: device.createdAt,
-          staleAt: device.staleAt,
         })
       ),
+      knownDeviceIdentities: userRecord?.knownDeviceIdentities || [],
     }
     return this.storage.put(this.userRecordKey(publicKey), data)
   }
@@ -671,65 +878,66 @@ export class SessionManager {
 
         const devices = new Map<string, DeviceRecord>()
 
+        const deserializeSession = (entry: StoredSessionEntry): Session => {
+          const session = new Session(this.nostrSubscribe, deserializeSessionState(entry.state))
+          session.name = entry.name
+          this.processedInviteResponses.add(entry.name)
+          return session
+        }
+
         for (const deviceData of data.devices) {
           const {
             deviceId,
             activeSession: serializedActive,
             inactiveSessions: serializedInactive,
             createdAt,
-            staleAt,
           } = deviceData
 
           try {
             const activeSession = serializedActive
-              ? new Session(
-                  this.nostrSubscribe,
-                  deserializeSessionState(serializedActive)
-                )
+              ? deserializeSession(serializedActive)
               : undefined
 
-            const inactiveSessions = serializedInactive.map(
-              (entry) => new Session(this.nostrSubscribe, deserializeSessionState(entry))
-            )
+            const inactiveSessions = serializedInactive.map(deserializeSession)
 
             devices.set(deviceId, {
               deviceId,
               activeSession,
               inactiveSessions,
               createdAt,
-              staleAt,
             })
-          } catch (e) {
-            console.error(
-              `Failed to deserialize session for user ${publicKey}, device ${deviceId}:`,
-              e
-            )
+          } catch {
+            // Failed to deserialize session
           }
         }
 
+        const knownDeviceIdentities = data.knownDeviceIdentities || []
+
         this.userRecords.set(publicKey, {
           publicKey: data.publicKey,
           devices,
+          knownDeviceIdentities,
         })
 
-        if (publicKey !== this.ourPublicKey) {
-          this.attachInviteTombstoneSubscription(publicKey)
+        // Rebuild delegateToOwner mapping from stored device identities
+        for (const identity of knownDeviceIdentities) {
+          this.delegateToOwner.set(identity, publicKey)
         }
 
         for (const device of devices.values()) {
-          const { deviceId, activeSession, inactiveSessions, staleAt } = device
-          if (!deviceId || staleAt !== undefined) continue
+          const { deviceId, activeSession, inactiveSessions } = device
+          if (!deviceId) continue
 
           for (const session of inactiveSessions.reverse()) {
-            this.attachSessionSubscription(publicKey, device, session)
+            this.attachSessionSubscription(publicKey, device, session, true)  // Restore as inactive
           }
           if (activeSession) {
-            this.attachSessionSubscription(publicKey, device, activeSession)
+            this.attachSessionSubscription(publicKey, device, activeSession)  // Restore as active
           }
         }
       })
-      .catch((error) => {
-        console.error(`Failed to load user record for ${publicKey}:`, error)
+      .catch(() => {
+        // Failed to load user record
       })
   }
 
@@ -751,34 +959,12 @@ export class SessionManager {
 
     // First migration
     if (!version) {
-      // Fetch all existing invites
-      // Assume no version prefix
-      // Deserialize and serialize to start using persistent createdAt
-      // Re-save invites with proper keys
+      // Delete old invite data (legacy format no longer supported)
       const oldInvitePrefix = "invite/"
       const inviteKeys = await this.storage.list(oldInvitePrefix)
-      await Promise.all(
-        inviteKeys.map(async (key) => {
-          try {
-            const publicKey = key.slice(oldInvitePrefix.length)
-            const inviteData = await this.storage.get<string>(key)
-            if (inviteData) {
-              const newKey = this.userInviteKey(publicKey)
-              const invite = Invite.deserialize(inviteData)
-              const serializedInvite = invite.serialize()
-              await this.storage.put(newKey, serializedInvite)
-              await this.storage.del(key)
-            }
-          } catch (e) {
-            console.error("Migration error for invite:", e)
-          }
-        })
-      )
+      await Promise.all(inviteKeys.map((key) => this.storage.del(key)))
 
-      // Fetch all existing user records
-      // Assume no version prefix
-      // Remove all old sessions as these may have key issues
-      // Re-save user records without sessions with proper keys
+      // Migrate old user records (clear sessions, keep device records)
       const oldUserRecordPrefix = "user/"
       const sessionKeys = await this.storage.list(oldUserRecordPrefix)
       await Promise.all(
@@ -800,22 +986,14 @@ export class SessionManager {
               await this.storage.put(newKey, newUserRecordData)
               await this.storage.del(key)
             }
-          } catch (e) {
-            console.error("Migration error for user record:", e)
+          } catch {
+            // Migration error for user record
           }
         })
       )
 
-      // Set version to 1 so next migration can run
       version = "1"
       await this.storage.put(this.versionKey(), version)
-
-      return
-    }
-
-    // Future migrations
-    if (version === "1") {
-      return
     }
   }
 }