nostr-double-ratchet 0.0.14 → 0.0.16

package/src/Session.ts

@@ -1,17 +1,22 @@
-import { generateSecretKey, getPublicKey, nip44, finalizeEvent, VerifiedEvent } from "nostr-tools";
+import { generateSecretKey, getPublicKey, nip44, finalizeEvent, VerifiedEvent, UnsignedEvent, getEventHash, validateEvent } from "nostr-tools";
 import { bytesToHex } from "@noble/hashes/utils";
 import {
   SessionState,
   Header,
   Unsubscribe,
   NostrSubscribe,
-  MessageCallback,
+  EventCallback,
   MESSAGE_EVENT_KIND,
+  Rumor,
+  CHAT_MESSAGE_KIND,
 } from "./types";
 import { kdf, skippedMessageIndexKey } from "./utils";
 
 const MAX_SKIP = 1000;
 
+// 64 zeros
+const DUMMY_PUBKEY = '0000000000000000000000000000000000000000000000000000000000000000'
+
 /**
  * Double ratchet secure communication session over Nostr
  * 
@@ -21,7 +26,7 @@ const MAX_SKIP = 1000;
 export class Session {
   private nostrUnsubscribe?: Unsubscribe;
   private nostrNextUnsubscribe?: Unsubscribe;
-  private internalSubscriptions = new Map<number, MessageCallback>();
+  private internalSubscriptions = new Map<number, EventCallback>();
   private currentInternalSubscriptionId = 0;
   public name: string;
 
@@ -70,17 +75,50 @@ export class Session {
   }
 
   /**
-   * Sends an encrypted message through the session
-   * @param data The plaintext message to send
+   * Sends a text message through the encrypted session
+   * @param text The plaintext message to send
    * @returns A verified Nostr event containing the encrypted message
    * @throws Error if we are not the initiator and trying to send the first message
    */
-  send(data: string): VerifiedEvent {
+  send(text: string): VerifiedEvent {
+    return this.sendEvent({
+      content: text,
+      kind: CHAT_MESSAGE_KIND
+    });
+  }
+
+  /**
+   * Send a partial Nostr event through the encrypted session.
+   * In addition to chat messages, it could be files, webrtc negotiation or many other types of messages.
+   * @param event Partial Nostr event to send. Must be unsigned. Id and will be generated if not provided.
+   * @returns A verified Nostr event containing the encrypted message
+   * @throws Error if we are not the initiator and trying to send the first message
+   */
+  sendEvent(event: Partial<UnsignedEvent>): VerifiedEvent {
     if (!this.state.theirNextNostrPublicKey || !this.state.ourCurrentNostrKey) {
       throw new Error("we are not the initiator, so we can't send the first message");
     }
 
-    const [header, encryptedData] = this.ratchetEncrypt(data);
+    if ("sig" in event) {
+      throw new Error("Event must be unsigned " + JSON.stringify(event));
+    }
+
+    const rumor: Partial<Rumor> = {
+      ...event,
+      content: event.content || "",
+      kind: event.kind || MESSAGE_EVENT_KIND,
+      created_at: event.created_at || Math.floor(Date.now() / 1000),
+      tags: event.tags || [],
+      pubkey: event.pubkey || DUMMY_PUBKEY,
+    }
+
+    if (!rumor.tags!.some(([k]) => k === "ms")) {
+      rumor.tags!.push(["ms", Date.now().toString()])
+    }
+
+    rumor.id = getEventHash(rumor as Rumor);
+
+    const [header, encryptedData] = this.ratchetEncrypt(JSON.stringify(rumor));
     
     const sharedSecret = nip44.getConversationKey(this.state.ourCurrentNostrKey.privateKey, this.state.theirNextNostrPublicKey);
     const encryptedHeader = nip44.encrypt(JSON.stringify(header), sharedSecret);
@@ -100,7 +138,7 @@ export class Session {
    * @param callback Function to be called when a message is received
    * @returns Unsubscribe function to stop receiving messages
    */
-  onMessage(callback: MessageCallback): Unsubscribe {
+  onEvent(callback: EventCallback): Unsubscribe {
     const id = this.currentInternalSubscriptionId++
     this.internalSubscriptions.set(id, callback)
     this.subscribeToNostrEvents()
@@ -122,7 +160,6 @@ export class Session {
     const header: Header = {
       number: this.state.sendingChainMessageNumber++,
       nextPublicKey: this.state.ourNextNostrKey.publicKey,
-      time: Date.now(),
       previousChainLength: this.state.previousSendingChainMessageCount
     };
     return [header, nip44.encrypt(plaintext, messageKey)];
@@ -283,9 +320,19 @@ export class Session {
       }
     }
 
-    const data = this.ratchetDecrypt(header, e.content, e.pubkey);
+    const text = this.ratchetDecrypt(header, e.content, e.pubkey);
+    const innerEvent = JSON.parse(text);
+    if (!validateEvent(innerEvent)) {
+      console.error("Invalid event received", innerEvent);
+      return;
+    }
+
+    if (innerEvent.id !== getEventHash(innerEvent)) {
+      console.error("Event hash does not match", innerEvent);
+      return;
+    }
 
-    this.internalSubscriptions.forEach(callback => callback({id: e.id, data, pubkey: header.nextPublicKey, time: header.time}));  
+    this.internalSubscriptions.forEach(callback => callback(innerEvent, e));  
   }
 
   private subscribeToNostrEvents() {

package/src/types.ts

@@ -1,20 +1,9 @@
 import { Filter, UnsignedEvent, VerifiedEvent } from "nostr-tools";
 
-/**
- * An event that has been verified to be from the Nostr network.
- */
-export type Message = {
-  id: string;
-  data: string;
-  pubkey: string;
-  time: number; // unlike Nostr, we use milliseconds instead of seconds
-}
-
 export type Header = {
   number: number;
   previousChainLength: number;
   nextPublicKey: string;
-  time: number;
 }
 
 /**
@@ -76,14 +65,26 @@ export type Unsubscribe = () => void;
  */
 export type NostrSubscribe = (filter: Filter, onEvent: (e: VerifiedEvent) => void) => Unsubscribe;
 
+export type Rumor = UnsignedEvent & { id: string }
+
 /** 
  * Callback function for handling decrypted messages
  * @param message - The decrypted message object
  */
-export type MessageCallback = (message: Message) => void;
+export type EventCallback = (event: Rumor, outerEvent: VerifiedEvent) => void;
+
+/**
+ * Message event kind
+ */
+export const MESSAGE_EVENT_KIND = 30078;
 
-export const MESSAGE_EVENT_KIND = 4;
+/**
+ * Invite event kind
+ */
 export const INVITE_EVENT_KIND = 30078;
+
+export const CHAT_MESSAGE_KIND = 14;
+
 export const MAX_SKIP = 100;
 
 export type NostrEvent = {
@@ -96,11 +97,6 @@ export type NostrEvent = {
   sig: string;
 }
 
-export enum Sender {
-  Us,
-  Them
-}
-
 export type EncryptFunction = (plaintext: string, pubkey: string) => Promise<string>;
 export type DecryptFunction = (ciphertext: string, pubkey: string) => Promise<string>;
 export type NostrPublish = (event: UnsignedEvent) => Promise<VerifiedEvent>;

package/src/utils.ts

@@ -1,5 +1,5 @@
 import { hexToBytes, bytesToHex } from "@noble/hashes/utils";
-import { SessionState, Message } from "./types";
+import { Rumor, SessionState } from "./types";
 import { Session } from "./Session.ts";
 import { extract as hkdf_extract, expand as hkdf_expand } from '@noble/hashes/hkdf';
 import { sha256 } from '@noble/hashes/sha256';
@@ -71,16 +71,16 @@ export function deserializeSessionState(data: string): SessionState {
   };
 }
 
-export async function* createMessageStream(session: Session): AsyncGenerator<Message, void, unknown> {
-  const messageQueue: Message[] = [];
-  let resolveNext: ((value: Message) => void) | null = null;
+export async function* createEventStream(session: Session): AsyncGenerator<Rumor, void, unknown> {
+  const messageQueue: Rumor[] = [];
+  let resolveNext: ((value: Rumor) => void) | null = null;
 
-  const unsubscribe = session.onMessage((message) => {
+  const unsubscribe = session.onEvent((event) => {
     if (resolveNext) {
-      resolveNext(message);
+      resolveNext(event);
       resolveNext = null;
     } else {
-      messageQueue.push(message);
+      messageQueue.push(event);
     }
   });
 
@@ -89,7 +89,7 @@ export async function* createMessageStream(session: Session): AsyncGenerator<Mes
       if (messageQueue.length > 0) {
         yield messageQueue.shift()!;
       } else {
-        yield new Promise<Message>(resolve => {
+        yield new Promise<Rumor>(resolve => {
           resolveNext = resolve;
         });
       }