nostr-double-ratchet 0.0.7 → 0.0.9

package/src/{InviteLink.ts → Invite.ts}

@@ -1,23 +1,22 @@
-import { generateSecretKey, getPublicKey, nip44, finalizeEvent, VerifiedEvent, nip19 } from "nostr-tools";
-import { NostrSubscribe, Unsubscribe } from "./types";
+import { generateSecretKey, getPublicKey, nip44, finalizeEvent, VerifiedEvent, nip19, UnsignedEvent, verifyEvent, Filter } from "nostr-tools";
+import { INVITE_EVENT_KIND, NostrSubscribe, Unsubscribe } from "./types";
 import { getConversationKey } from "nostr-tools/nip44";
 import { Channel } from "./Channel";
-import { EVENT_KIND } from "./types";
+import { MESSAGE_EVENT_KIND } from "./types";
 import { EncryptFunction, DecryptFunction } from "./types";
 import { hexToBytes, bytesToHex } from "@noble/hashes/utils";
 
 /**
- * Invite link is a safe way to exchange session keys and initiate secret channels.
+ * Invite is a safe way to exchange session keys and initiate secret channels.
+ * 
+ * It can be shared privately as an URL (e.g. QR code) or published as a Nostr event.
  * 
  * Even if inviter's or invitee's long-term private key (identity key) and the shared secret (link) is compromised,
  * forward secrecy is preserved as long as the session keys are not compromised.
  * 
- * Shared secret Nostr channel: inviter listens to it and invitees can write to it. Outside observers don't know who are communicating over it.
- * It is vulnerable to spam, so the link should only be given to trusted invitees or used with a reasonable maxUses limit.
- * 
  * Also make sure to keep the session key safe.
  */
-export class InviteLink {
+export class Invite {
     constructor(
         public inviterSessionPublicKey: string,
         public linkSecret: string,
@@ -28,11 +27,11 @@ export class InviteLink {
         public usedBy: string[] = [],
     ) {}
 
-    static createNew(inviter: string, label?: string, maxUses?: number): InviteLink {
+    static createNew(inviter: string, label?: string, maxUses?: number): Invite {
         const inviterSessionPrivateKey = generateSecretKey();
         const inviterSessionPublicKey = getPublicKey(inviterSessionPrivateKey);
         const linkSecret = bytesToHex(generateSecretKey());
-        return new InviteLink(
+        return new Invite(
             inviterSessionPublicKey,
             linkSecret,
             inviter,
@@ -42,7 +41,7 @@ export class InviteLink {
         );
     }
 
-    static fromUrl(url: string): InviteLink {
+    static fromUrl(url: string): Invite {
         const parsedUrl = new URL(url);
         const rawHash = parsedUrl.hash.slice(1);
         if (!rawHash) {
@@ -72,16 +71,16 @@ export class InviteLink {
             throw new Error("Decoded session key is not a string");
         }
 
-        return new InviteLink(
+        return new Invite(
             decodedSessionKey.data,
             linkSecret,
             decodedInviter.data
         );
     }
 
-    static deserialize(json: string): InviteLink {
+    static deserialize(json: string): Invite {
         const data = JSON.parse(json);
-        return new InviteLink(
+        return new Invite(
             data.inviterSessionPublicKey,
             data.linkSecret,
             data.inviter,
@@ -92,6 +91,59 @@ export class InviteLink {
         );
     }
 
+    static fromEvent(event: VerifiedEvent): Invite {
+        if (!event.sig) {
+            throw new Error("Event is not signed");
+        }
+        if (!verifyEvent(event)) {
+            throw new Error("Event signature is invalid");
+        }
+        const { tags } = event;
+        const inviterSessionPublicKey = tags.find(([key]) => key === 'sessionKey')?.[1];
+        const linkSecret = tags.find(([key]) => key === 'linkSecret')?.[1];
+        const inviter = event.pubkey;
+
+        if (!inviterSessionPublicKey || !linkSecret) {
+            throw new Error("Invalid invite event: missing session key or link secret");
+        }
+
+        return new Invite(
+            inviterSessionPublicKey,
+            linkSecret,
+            inviter
+        );
+    }
+
+    static fromUser(user: string, subscribe: NostrSubscribe): Promise<Invite | undefined> {
+        const filter: Filter = {
+            kinds: [INVITE_EVENT_KIND],
+            authors: [user],
+            limit: 1,
+            "#d": ["nostr-double-ratchet/invite"],
+        };
+        return new Promise((resolve) => {
+            const unsub = subscribe(filter, (event) => {
+                try {
+                    const inviteLink = Invite.fromEvent(event);
+                    unsub();
+                    resolve(inviteLink);
+                } catch (error) {
+                    unsub();
+                    resolve(undefined);
+                }
+            });
+
+            // Set timeout to unsubscribe and return undefined after 10 seconds
+            setTimeout(() => {
+                unsub();
+                resolve(undefined);
+            }, 10000);
+        });
+    }
+
+    /**
+     * Save Invite as JSON. Includes the inviter's session private key, so don't share this.
+     */
     serialize(): string {
         return JSON.stringify({
             inviterSessionPublicKey: this.inviterSessionPublicKey,
@@ -104,6 +156,9 @@ export class InviteLink {
         });
     }
 
+    /**
+     * Invite parameters are in the URL's hash so they are not sent to the server.
+     */
     getUrl(root = "https://iris.to") {
         const data = {
             inviter: nip19.npubEncode(this.inviter),
@@ -116,8 +171,18 @@ export class InviteLink {
         return url.toString();
     }
 
+    getEvent(): UnsignedEvent {
+        return {
+            kind: INVITE_EVENT_KIND,
+            pubkey: this.inviter,
+            content: "",
+            created_at: Math.floor(Date.now() / 1000),
+            tags: [['sessionKey', this.inviterSessionPublicKey], ['linkSecret', this.linkSecret], ['d', 'nostr-double-ratchet/invite']],
+        };
+    }
+
     /**
-     * Accepts the invite and creates a new channel with the inviter.
+     * Called by the invitee. Accepts the invite and creates a new channel with the inviter.
      * 
      * @param inviteeSecretKey - The invitee's secret key or a signing function
      * @param nostrSubscribe - A function to subscribe to Nostr events
@@ -131,7 +196,7 @@ export class InviteLink {
      * Note: You need to publish the returned event on Nostr using NDK or another Nostr system of your choice,
      * so the inviter can create the channel on their side.
      */
-    async acceptInvite(
+    async accept(
         nostrSubscribe: NostrSubscribe,
         inviteePublicKey: string,
         inviteeSecretKey: Uint8Array | EncryptFunction,
@@ -159,7 +224,7 @@ export class InviteLink {
         };
 
         const envelope = {
-            kind: EVENT_KIND,
+            kind: MESSAGE_EVENT_KIND,
             pubkey: randomSenderPublicKey,
             content: nip44.encrypt(JSON.stringify(innerEvent), getConversationKey(randomSenderKey, this.inviterSessionPublicKey)),
             created_at: Math.floor(Date.now() / 1000),
@@ -175,12 +240,17 @@ export class InviteLink {
         }
         
         const filter = {
-            kinds: [EVENT_KIND],
+            kinds: [MESSAGE_EVENT_KIND],
             '#p': [this.inviterSessionPublicKey],
         };
 
         return nostrSubscribe(filter, async (event) => {
             try {
+                if (this.maxUses && this.usedBy.length >= this.maxUses) {
+                    console.error("Invite has reached maximum number of uses");
+                    return;
+                }
+
                 const decrypted = await nip44.decrypt(event.content, getConversationKey(this.inviterSessionPrivateKey!, event.pubkey));
                 const innerEvent = JSON.parse(decrypted);
 
@@ -193,13 +263,16 @@ export class InviteLink {
                     inviterSecretKey :
                     (ciphertext: string, pubkey: string) => Promise.resolve(nip44.decrypt(ciphertext, getConversationKey(inviterSecretKey, pubkey)));
     
-                const inviteeSessionPublicKey = await innerDecrypt(innerEvent.content, innerEvent.pubkey);
+                const inviteeIdentity = innerEvent.pubkey;
+                this.usedBy.push(inviteeIdentity);
+
+                const inviteeSessionPublicKey = await innerDecrypt(innerEvent.content, inviteeIdentity);
                 const sharedSecret = hexToBytes(this.linkSecret);
 
                 const name = event.id;
                 const channel = Channel.init(nostrSubscribe, inviteeSessionPublicKey, this.inviterSessionPrivateKey!, false, sharedSecret, name);
 
-                onChannel(channel, innerEvent.pubkey);
+                onChannel(channel, inviteeIdentity);
             } catch (error) {
                 console.error("Error processing invite message:", error);
             }

package/src/index.ts

@@ -1,4 +1,4 @@
 export * from "./Channel"
-export * from "./InviteLink"
+export * from "./Invite"
 export * from "./types"
 export * from "./utils"

package/src/types.ts

@@ -1,4 +1,4 @@
-import { VerifiedEvent } from "nostr-tools";
+import { Filter, UnsignedEvent, VerifiedEvent } from "nostr-tools";
 
 /**
  * An event that has been verified to be from the Nostr network.
@@ -17,11 +17,6 @@ export type Header = {
   time: number;
 }
 
-export type NostrFilter = {
-  authors?: string[];
-  kinds?: number[];
-}
-
 /**
  * A keypair used for encryption and decryption.
  */
@@ -76,7 +71,7 @@ export type Unsubscribe = () => void;
 /** 
  * Function that subscribes to Nostr events matching a filter and calls onEvent for each event.
  */
-export type NostrSubscribe = (filter: NostrFilter, onEvent: (e: VerifiedEvent) => void) => Unsubscribe;
+export type NostrSubscribe = (filter: Filter, onEvent: (e: VerifiedEvent) => void) => Unsubscribe;
 
 /** 
  * Callback function for handling decrypted messages
@@ -84,7 +79,8 @@ export type NostrSubscribe = (filter: NostrFilter, onEvent: (e: VerifiedEvent) =
  */
 export type MessageCallback = (message: Message) => void;
 
-export const EVENT_KIND = 4;
+export const MESSAGE_EVENT_KIND = 4;
+export const INVITE_EVENT_KIND = 30078;
 export const MAX_SKIP = 100;
 
 export type NostrEvent = {
@@ -103,4 +99,5 @@ export enum Sender {
 }
 
 export type EncryptFunction = (plaintext: string, pubkey: string) => Promise<string>;
-export type DecryptFunction = (ciphertext: string, pubkey: string) => Promise<string>;
+export type DecryptFunction = (ciphertext: string, pubkey: string) => Promise<string>;
+export type NostrPublish = (event: UnsignedEvent) => Promise<VerifiedEvent>;

package/dist/InviteLink.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"InviteLink.d.ts","sourceRoot":"","sources":["../src/InviteLink.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyD,aAAa,EAAS,MAAM,aAAa,CAAC;AAC1G,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG3D;;;;;;;;;;GAUG;AACH,qBAAa,UAAU;IAER,uBAAuB,EAAE,MAAM;IAC/B,UAAU,EAAE,MAAM;IAClB,OAAO,EAAE,MAAM;IACf,wBAAwB,CAAC,EAAE,UAAU;IACrC,KAAK,CAAC,EAAE,MAAM;IACd,OAAO,CAAC,EAAE,MAAM;IAChB,MAAM,EAAE,MAAM,EAAE;gBANhB,uBAAuB,EAAE,MAAM,EAC/B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,wBAAwB,CAAC,EAAE,UAAU,YAAA,EACrC,KAAK,CAAC,EAAE,MAAM,YAAA,EACd,OAAO,CAAC,EAAE,MAAM,YAAA,EAChB,MAAM,GAAE,MAAM,EAAO;IAGhC,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU;IAc/E,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU;IAqCvC,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAa5C,SAAS,IAAI,MAAM;IAYnB,MAAM,CAAC,IAAI,SAAoB;IAY/B;;;;;;;;;;;;;;OAcG;IACG,YAAY,CACd,cAAc,EAAE,cAAc,EAC9B,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,UAAU,GAAG,eAAe,GAC/C,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,aAAa,CAAA;KAAE,CAAC;IAkCtD,MAAM,CAAC,gBAAgB,EAAE,UAAU,GAAG,eAAe,EAAE,cAAc,EAAE,cAAc,EAAE,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,GAAG,WAAW;CAoChK"}