nostr-double-ratchet 0.0.38 → 0.0.48

package/src/InviteList.ts

@@ -1,333 +0,0 @@
-import { finalizeEvent, VerifiedEvent, UnsignedEvent, verifyEvent } from "nostr-tools"
-import {
-  NostrSubscribe,
-  Unsubscribe,
-  EncryptFunction,
-  DecryptFunction,
-  INVITE_LIST_EVENT_KIND,
-  INVITE_RESPONSE_KIND,
-} from "./types"
-import { Session } from "./Session"
-import {
-  generateEphemeralKeypair,
-  generateSharedSecret,
-  generateDeviceId,
-  encryptInviteResponse,
-  decryptInviteResponse,
-  createSessionFromAccept,
-} from "./inviteUtils"
-
-const now = () => Math.round(Date.now() / 1000)
-
-type DeviceTag = [
-  type: "device",
-  ephemeralPublicKey: string,
-  sharedSecret: string,
-  deviceId: string,
-  createdAt: string,
-  identityPubkey: string,
-]
-
-type RemovedTag = [type: "removed", deviceId: string]
-
-const isDeviceTag = (tag: string[]): tag is DeviceTag =>
-  tag.length >= 6 &&
-  tag[0] === "device" &&
-  tag.slice(1, 6).every((v) => typeof v === "string")
-
-const isRemovedTag = (tag: string[]): tag is RemovedTag =>
-  tag.length >= 2 &&
-  tag[0] === "removed" &&
-  typeof tag[1] === "string"
-
-export interface DeviceEntry {
-  ephemeralPublicKey: string
-  /** Only stored locally, not published */
-  ephemeralPrivateKey?: Uint8Array
-  sharedSecret: string
-  deviceId: string
-  deviceLabel: string
-  createdAt: number
-  /** Owner's pubkey for owner devices, delegate's own pubkey for delegate devices */
-  identityPubkey: string
-}
-
-interface SerializedDeviceEntry extends Omit<DeviceEntry, 'ephemeralPrivateKey'> {
-  ephemeralPrivateKey?: number[]
-}
-
-/**
- * Manages a consolidated list of device invites (kind 10078).
- * Single atomic event containing all device invites for a user.
- * Uses union merge strategy for conflict resolution.
- */
-export class InviteList {
-  private devices: Map<string, DeviceEntry> = new Map()
-  private removedDeviceIds: Set<string> = new Set()
-
-  constructor(
-    public readonly ownerPublicKey: string,
-    devices: DeviceEntry[] = [],
-    removedDeviceIds: string[] = [],
-  ) {
-    this.removedDeviceIds = new Set(removedDeviceIds)
-    devices
-      .filter((device) => !this.removedDeviceIds.has(device.deviceId))
-      .forEach((device) => this.devices.set(device.deviceId, device))
-  }
-
-  createDevice(label: string, deviceId?: string): DeviceEntry {
-    const keypair = generateEphemeralKeypair()
-    return {
-      ephemeralPublicKey: keypair.publicKey,
-      ephemeralPrivateKey: keypair.privateKey,
-      sharedSecret: generateSharedSecret(),
-      deviceId: deviceId || generateDeviceId(),
-      deviceLabel: label,
-      createdAt: now(),
-      identityPubkey: this.ownerPublicKey,
-    }
-  }
-
-  addDevice(device: DeviceEntry): void {
-    if (this.removedDeviceIds.has(device.deviceId)) {
-      return
-    }
-    if (!this.devices.has(device.deviceId)) {
-      this.devices.set(device.deviceId, device)
-    }
-  }
-
-  removeDevice(deviceId: string): void {
-    this.devices.delete(deviceId)
-    this.removedDeviceIds.add(deviceId)
-  }
-
-  getDevice(deviceId: string): DeviceEntry | undefined {
-    return this.devices.get(deviceId)
-  }
-
-  getAllDevices(): DeviceEntry[] {
-    return Array.from(this.devices.values())
-  }
-
-  getRemovedDeviceIds(): string[] {
-    return Array.from(this.removedDeviceIds)
-  }
-
-  updateDeviceLabel(deviceId: string, newLabel: string): void {
-    const device = this.devices.get(deviceId)
-    if (device) {
-      device.deviceLabel = newLabel
-    }
-  }
-
-  getEvent(): UnsignedEvent {
-    const deviceTags = this.getAllDevices().map((device) => [
-      "device",
-      device.ephemeralPublicKey,
-      device.sharedSecret,
-      device.deviceId,
-      String(device.createdAt),
-      device.identityPubkey,
-    ])
-
-    const removedTags = this.getRemovedDeviceIds().map((deviceId) => [
-      "removed",
-      deviceId,
-    ])
-
-    return {
-      kind: INVITE_LIST_EVENT_KIND,
-      pubkey: this.ownerPublicKey,
-      content: "",
-      created_at: now(),
-      tags: [
-        ["d", "double-ratchet/invite-list"],
-        ["version", "1"],
-        ...deviceTags,
-        ...removedTags,
-      ],
-    }
-  }
-
-  static fromEvent(event: VerifiedEvent): InviteList {
-    if (!event.sig) {
-      throw new Error("Event is not signed")
-    }
-    if (!verifyEvent(event)) {
-      throw new Error("Event signature is invalid")
-    }
-
-    const devices = event.tags
-      .filter(isDeviceTag)
-      .map(([, ephemeralPublicKey, sharedSecret, deviceId, createdAt, identityPubkey]) => ({
-        ephemeralPublicKey,
-        sharedSecret,
-        deviceId,
-        deviceLabel: deviceId,
-        createdAt: parseInt(createdAt, 10) || event.created_at,
-        identityPubkey,
-      }))
-
-    const removedDeviceIds = event.tags
-      .filter(isRemovedTag)
-      .map(([, deviceId]) => deviceId)
-
-    return new InviteList(event.pubkey, devices, removedDeviceIds)
-  }
-
-  serialize(): string {
-    const devices = this.getAllDevices().map((d) => ({
-      ...d,
-      ephemeralPrivateKey: d.ephemeralPrivateKey
-        ? Array.from(d.ephemeralPrivateKey)
-        : undefined,
-    }))
-
-    return JSON.stringify({
-      ownerPublicKey: this.ownerPublicKey,
-      devices,
-      removedDeviceIds: this.getRemovedDeviceIds(),
-    })
-  }
-
-  static deserialize(json: string): InviteList {
-    const data = JSON.parse(json) as { ownerPublicKey: string; devices: SerializedDeviceEntry[]; removedDeviceIds?: string[] }
-    const devices: DeviceEntry[] = data.devices.map((d) => ({
-      ...d,
-      ephemeralPrivateKey: d.ephemeralPrivateKey
-        ? new Uint8Array(d.ephemeralPrivateKey)
-        : undefined,
-    }))
-
-    return new InviteList(data.ownerPublicKey, devices, data.removedDeviceIds || [])
-  }
-
-  merge(other: InviteList): InviteList {
-    const mergedRemovedIds = new Set([
-      ...this.removedDeviceIds,
-      ...other.removedDeviceIds,
-    ])
-
-    const mergedDevices = [...this.devices.values(), ...other.devices.values()]
-      .reduce((map, device) => {
-        const existing = map.get(device.deviceId)
-        map.set(device.deviceId, existing
-          ? { ...device, ephemeralPrivateKey: existing.ephemeralPrivateKey || device.ephemeralPrivateKey }
-          : device
-        )
-        return map
-      }, new Map<string, DeviceEntry>())
-
-    const activeDevices = Array.from(mergedDevices.values())
-      .filter((device) => !mergedRemovedIds.has(device.deviceId))
-
-    return new InviteList(
-      this.ownerPublicKey,
-      activeDevices,
-      Array.from(mergedRemovedIds)
-    )
-  }
-
-  async accept(
-    deviceId: string,
-    nostrSubscribe: NostrSubscribe,
-    inviteePublicKey: string,
-    encryptor: Uint8Array | EncryptFunction,
-    inviteeDeviceId?: string
-  ): Promise<{ session: Session; event: VerifiedEvent }> {
-    const device = this.devices.get(deviceId)
-    if (!device) {
-      throw new Error(`Device ${deviceId} not found in invite list`)
-    }
-
-    const inviteeSessionKeypair = generateEphemeralKeypair()
-
-    const session = createSessionFromAccept({
-      nostrSubscribe,
-      theirPublicKey: device.ephemeralPublicKey,
-      ourSessionPrivateKey: inviteeSessionKeypair.privateKey,
-      sharedSecret: device.sharedSecret,
-      isSender: true,
-    })
-
-    const encrypt = typeof encryptor === "function" ? encryptor : undefined
-    const inviteePrivateKey = typeof encryptor === "function" ? undefined : encryptor
-
-    const encrypted = await encryptInviteResponse({
-      inviteeSessionPublicKey: inviteeSessionKeypair.publicKey,
-      inviteePublicKey,
-      inviteePrivateKey,
-      inviterPublicKey: device.identityPubkey,
-      inviterEphemeralPublicKey: device.ephemeralPublicKey,
-      sharedSecret: device.sharedSecret,
-      deviceId: inviteeDeviceId,
-      encrypt,
-    })
-
-    return {
-      session,
-      event: finalizeEvent(encrypted.envelope, encrypted.randomSenderPrivateKey),
-    }
-  }
-
-  listen(
-    decryptor: Uint8Array | DecryptFunction,
-    nostrSubscribe: NostrSubscribe,
-    onSession: (
-      session: Session,
-      identity: string,
-      deviceId?: string,
-      ourDeviceId?: string
-    ) => void
-  ): Unsubscribe {
-    const devices = this.getAllDevices()
-    const decryptableDevices = devices.filter((d) => !!d.ephemeralPrivateKey)
-
-    // If we don't have any devices we can decrypt for, do nothing gracefully
-    if (decryptableDevices.length === 0) {
-      return () => {}
-    }
-
-    const ephemeralPubkeys = decryptableDevices.map((d) => d.ephemeralPublicKey)
-    const decrypt = typeof decryptor === "function" ? decryptor : undefined
-    const ownerPrivateKey = typeof decryptor === "function" ? undefined : decryptor
-
-    return nostrSubscribe(
-      { kinds: [INVITE_RESPONSE_KIND], "#p": ephemeralPubkeys },
-      async (event) => {
-        const targetPubkey = event.tags.find((t) => t[0] === "p")?.[1]
-        const device = decryptableDevices.find((d) => d.ephemeralPublicKey === targetPubkey)
-
-        if (!device || !device.ephemeralPrivateKey) {
-          return
-        }
-
-        try {
-          const decrypted = await decryptInviteResponse({
-            envelopeContent: event.content,
-            envelopeSenderPubkey: event.pubkey,
-            inviterEphemeralPrivateKey: device.ephemeralPrivateKey,
-            inviterPrivateKey: ownerPrivateKey,
-            sharedSecret: device.sharedSecret,
-            decrypt,
-          })
-
-          const session = createSessionFromAccept({
-            nostrSubscribe,
-            theirPublicKey: decrypted.inviteeSessionPublicKey,
-            ourSessionPrivateKey: device.ephemeralPrivateKey,
-            sharedSecret: device.sharedSecret,
-            isSender: false,
-            name: event.id,
-          })
-
-          onSession(session, decrypted.inviteeIdentity, decrypted.deviceId, device.deviceId)
-        } catch {
-          // Invalid response
-        }
-      }
-    )
-  }
-}

package/src/UserRecord.ts

@@ -1,338 +0,0 @@
-import { Session } from './Session';
-import { NostrSubscribe } from './types';
-
-interface DeviceRecord {
-  deviceId: string;
-  publicKey: string;
-  activeSession?: Session;
-  inactiveSessions: Session[];
-  isStale: boolean;
-  staleTimestamp?: number;
-  lastActivity?: number;
-}
-
-/**
- * Manages sessions for a single user across multiple devices
- * Structure: UserRecord → DeviceRecord → Sessions
- */
-export class UserRecord {
-  private deviceRecords: Map<string, DeviceRecord> = new Map();
-  private isStale: boolean = false;
-  private staleTimestamp?: number;
-
-  constructor(
-    public readonly userId: string,
-    private readonly nostrSubscribe: NostrSubscribe,
-  ) {
-  }
-
-  // ============================================================================
-  // Device Management
-  // ============================================================================
-
-  /**
-   * Creates or updates a device record for this user
-   */
-  public upsertDevice(deviceId: string, publicKey: string): DeviceRecord {
-    let record = this.deviceRecords.get(deviceId);
-    
-    if (!record) {
-      record = {
-        deviceId,
-        publicKey,
-        inactiveSessions: [],
-        isStale: false,
-        lastActivity: Date.now()
-      };
-      this.deviceRecords.set(deviceId, record);
-    } else if (record.publicKey !== publicKey) {
-      // Public key changed - mark old sessions as inactive and update
-      if (record.activeSession) {
-        record.inactiveSessions.push(record.activeSession);
-        record.activeSession = undefined;
-      }
-      record.publicKey = publicKey;
-      record.lastActivity = Date.now();
-    }
-
-    return record;
-  }
-
-  /**
-   * Gets a device record by deviceId
-   */
-  public getDevice(deviceId: string): DeviceRecord | undefined {
-    return this.deviceRecords.get(deviceId);
-  }
-
-  /**
-   * Gets all device records for this user
-   */
-  public getAllDevices(): DeviceRecord[] {
-    return Array.from(this.deviceRecords.values());
-  }
-
-  /**
-   * Gets all active (non-stale) device records
-   */
-  public getActiveDevices(): DeviceRecord[] {
-    if (this.isStale) return [];
-    return Array.from(this.deviceRecords.values()).filter(device => !device.isStale);
-  }
-
-  /**
-   * Removes a device record and closes all its sessions
-   */
-  public removeDevice(deviceId: string): boolean {
-    const record = this.deviceRecords.get(deviceId);
-    if (!record) return false;
-
-    // Close all sessions for this device
-    record.activeSession?.close();
-    record.inactiveSessions.forEach(session => session.close());
-    
-    return this.deviceRecords.delete(deviceId);
-  }
-
-  // ============================================================================
-  // Session Management
-  // ============================================================================
-
-  /**
-   * Adds or updates a session for a specific device
-   */
-  public upsertSession(deviceId: string, session: Session, publicKey?: string): void {
-    const device = this.upsertDevice(deviceId, publicKey || session.state?.theirNextNostrPublicKey || '');
-    
-    // If there's an active session, move it to inactive
-    if (device.activeSession) {
-      device.inactiveSessions.unshift(device.activeSession);
-    }
-
-    // Set the new session as active
-    session.name = deviceId; // Ensure session name matches deviceId
-    device.activeSession = session;
-    device.lastActivity = Date.now();
-  }
-
-  /**
-   * Gets the active session for a specific device
-   */
-  public getActiveSession(deviceId: string): Session | undefined {
-    const device = this.deviceRecords.get(deviceId);
-    return device?.isStale ? undefined : device?.activeSession;
-  }
-
-  /**
-   * Gets all sessions (active + inactive) for a specific device
-   */
-  public getDeviceSessions(deviceId: string): Session[] {
-    const device = this.deviceRecords.get(deviceId);
-    if (!device) return [];
-
-    const sessions: Session[] = [];
-    if (device.activeSession) {
-      sessions.push(device.activeSession);
-    }
-    sessions.push(...device.inactiveSessions);
-    return sessions;
-  }
-
-  /**
-   * Gets all active sessions across all devices for this user
-   */
-  public getActiveSessions(): Session[] {
-    const sessions: Session[] = [];
-
-    for (const device of this.getActiveDevices()) {
-      if (device.activeSession) {
-        sessions.push(device.activeSession);
-      }
-    }
-
-    // Sort by ability to send messages (prioritize ready sessions)
-    sessions.sort((a, b) => {
-      const aCanSend = !!(a.state?.theirNextNostrPublicKey && a.state?.ourCurrentNostrKey);
-      const bCanSend = !!(b.state?.theirNextNostrPublicKey && b.state?.ourCurrentNostrKey);
-      
-      if (aCanSend && !bCanSend) return -1;
-      if (!aCanSend && bCanSend) return 1;
-      return 0;
-    });
-
-    return sessions;
-  }
-
-  /**
-   * Gets all sessions (active + inactive) across all devices
-   */
-  public getAllSessions(): Session[] {
-    const sessions: Session[] = [];
-
-    for (const device of this.deviceRecords.values()) {
-      if (device.activeSession) {
-        sessions.push(device.activeSession);
-      }
-      sessions.push(...device.inactiveSessions);
-    }
-
-    return sessions;
-  }
-
-  /**
-   * Gets sessions that are ready to send messages
-   */
-  public getSendableSessions(): Session[] {
-    return this.getActiveSessions().filter(session => 
-      !!(session.state?.theirNextNostrPublicKey && session.state?.ourCurrentNostrKey)
-    );
-  }
-
-  // ============================================================================
-  // Stale Management
-  // ============================================================================
-
-  /**
-   * Marks a specific device as stale
-   */
-  public markDeviceStale(deviceId: string): void {
-    const device = this.deviceRecords.get(deviceId);
-    if (device) {
-      device.isStale = true;
-      device.staleTimestamp = Date.now();
-    }
-  }
-
-  /**
-   * Marks the entire user record as stale
-   */
-  public markUserStale(): void {
-    this.isStale = true;
-    this.staleTimestamp = Date.now();
-  }
-
-  /**
-   * Removes stale devices and sessions older than maxLatency
-   */
-  public pruneStaleRecords(maxLatency: number): void {
-    const now = Date.now();
-
-    // Remove stale devices
-    for (const [deviceId, device] of this.deviceRecords.entries()) {
-      if (device.isStale && device.staleTimestamp && 
-          (now - device.staleTimestamp) > maxLatency) {
-        this.removeDevice(deviceId);
-      }
-    }
-
-    // Remove entire user record if stale
-    if (this.isStale && this.staleTimestamp && 
-        (now - this.staleTimestamp) > maxLatency) {
-      this.close();
-    }
-  }
-
-  // ============================================================================
-  // Utility Methods
-  // ============================================================================
-
-  /**
-   * Gets the most recently active device
-   */
-  public getMostActiveDevice(): DeviceRecord | undefined {
-    const activeDevices = this.getActiveDevices();
-    if (activeDevices.length === 0) return undefined;
-
-    return activeDevices.reduce((most, current) => {
-      const mostActivity = most.lastActivity || 0;
-      const currentActivity = current.lastActivity || 0;
-      return currentActivity > mostActivity ? current : most;
-    });
-  }
-
-  /**
-   * Gets the preferred session (from most active device)
-   */
-  public getPreferredSession(): Session | undefined {
-    const mostActive = this.getMostActiveDevice();
-    return mostActive?.activeSession;
-  }
-
-  /**
-   * Checks if this user has any active sessions
-   */
-  public hasActiveSessions(): boolean {
-    return this.getActiveSessions().length > 0;
-  }
-
-  /**
-   * Gets total count of devices
-   */
-  public getDeviceCount(): number {
-    return this.deviceRecords.size;
-  }
-
-  /**
-   * Gets total count of active sessions
-   */
-  public getActiveSessionCount(): number {
-    return this.getActiveSessions().length;
-  }
-
-  /**
-   * Cleanup when destroying the user record
-   */
-  public close(): void {
-    for (const device of this.deviceRecords.values()) {
-      device.activeSession?.close();
-      device.inactiveSessions.forEach(session => session.close());
-    }
-    this.deviceRecords.clear();
-  }
-
-  // ============================================================================
-  // Legacy Compatibility Methods
-  // ============================================================================
-
-  /**
-   * @deprecated Use upsertDevice instead
-   */
-  public conditionalUpdate(deviceId: string, publicKey: string): void {
-    this.upsertDevice(deviceId, publicKey);
-  }
-
-  /**
-   * @deprecated Use upsertSession instead  
-   */
-  public insertSession(deviceId: string, session: Session): void {
-    this.upsertSession(deviceId, session);
-  }
-
-  /**
-   * Creates a new session for a device
-   */
-  public createSession(
-    deviceId: string, 
-    sharedSecret: Uint8Array,
-    ourCurrentPrivateKey: Uint8Array,
-    isInitiator: boolean,
-    name?: string
-  ): Session {
-    const device = this.getDevice(deviceId);
-    if (!device) {
-      throw new Error(`No device record found for ${deviceId}`);
-    }
-
-    const session = Session.init(
-      this.nostrSubscribe,
-      device.publicKey,
-      ourCurrentPrivateKey,
-      isInitiator,
-      sharedSecret,
-      name || deviceId
-    );
-
-    this.upsertSession(deviceId, session);
-    return session;
-  }
-}