@xmtp/browser-sdk 0.0.17 → 0.0.18

package/src/Conversations.ts

@@ -1,9 +1,14 @@
+import { ConversationType } from "@xmtp/wasm-bindings";
+import { v4 } from "uuid";
+import { AsyncStream, type StreamCallback } from "@/AsyncStream";
 import type { Client } from "@/Client";
 import { Conversation } from "@/Conversation";
 import { DecodedMessage } from "@/DecodedMessage";
 import type {
+  SafeConversation,
   SafeCreateGroupOptions,
   SafeListConversationsOptions,
+  SafeMessage,
 } from "@/utils/conversions";
 
 export class Conversations {
@@ -99,4 +104,78 @@ export class Conversations {
   async getHmacKeys() {
     return this.#client.sendMessage("getHmacKeys", undefined);
   }
+
+  async stream(
+    callback?: StreamCallback<Conversation>,
+    conversationType?: ConversationType,
+  ) {
+    const streamId = v4();
+    const asyncStream = new AsyncStream<Conversation>();
+    const endStream = this.#client.handleStreamMessage<SafeConversation>(
+      streamId,
+      (error, value) => {
+        const conversation = value
+          ? new Conversation(this.#client, value.id, value)
+          : undefined;
+        void asyncStream.callback(error, conversation);
+        void callback?.(error, conversation);
+      },
+    );
+    await this.#client.sendMessage("streamAllGroups", {
+      streamId,
+      conversationType,
+    });
+    asyncStream.onReturn = () => {
+      void this.#client.sendMessage("endStream", {
+        streamId,
+      });
+      endStream();
+    };
+    return asyncStream;
+  }
+
+  async streamGroups(callback?: StreamCallback<Conversation>) {
+    return this.stream(callback, ConversationType.Group);
+  }
+
+  async streamDms(callback?: StreamCallback<Conversation>) {
+    return this.stream(callback, ConversationType.Dm);
+  }
+
+  async streamAllMessages(
+    callback?: StreamCallback<DecodedMessage>,
+    conversationType?: ConversationType,
+  ) {
+    const streamId = v4();
+    const asyncStream = new AsyncStream<DecodedMessage>();
+    const endStream = this.#client.handleStreamMessage<SafeMessage>(
+      streamId,
+      (error, value) => {
+        const decodedMessage = value
+          ? new DecodedMessage(this.#client, value)
+          : undefined;
+        void asyncStream.callback(error, decodedMessage);
+        void callback?.(error, decodedMessage);
+      },
+    );
+    await this.#client.sendMessage("streamAllMessages", {
+      streamId,
+      conversationType,
+    });
+    asyncStream.onReturn = () => {
+      void this.#client.sendMessage("endStream", {
+        streamId,
+      });
+      endStream();
+    };
+    return asyncStream;
+  }
+
+  async streamAllGroupMessages(callback?: StreamCallback<DecodedMessage>) {
+    return this.streamAllMessages(callback, ConversationType.Group);
+  }
+
+  async streamAllDmMessages(callback?: StreamCallback<DecodedMessage>) {
+    return this.streamAllMessages(callback, ConversationType.Dm);
+  }
 }

package/src/WorkerClient.ts

@@ -51,9 +51,9 @@ export class WorkerClient {
     return this.#client.isRegistered;
   }
 
-  async createInboxSignatureText() {
+  createInboxSignatureText() {
     try {
-      return await this.#client.createInboxSignatureText();
+      return this.#client.createInboxSignatureText();
     } catch {
       return undefined;
     }

package/src/WorkerConversation.ts

@@ -3,10 +3,12 @@ import type {
   Conversation,
   EncodedContent,
   GroupMember,
+  Message,
   MetadataField,
   PermissionPolicy,
   PermissionUpdateType,
 } from "@xmtp/wasm-bindings";
+import { type StreamCallback } from "@/AsyncStream";
 import {
   fromSafeListMessagesOptions,
   toSafeGroupMember,
@@ -53,14 +55,6 @@ export class WorkerConversation {
     return this.#group.updateGroupDescription(description);
   }
 
-  get pinnedFrameUrl() {
-    return this.#group.groupPinnedFrameUrl();
-  }
-
-  async updatePinnedFrameUrl(pinnedFrameUrl: string) {
-    return this.#group.updateGroupPinnedFrameUrl(pinnedFrameUrl);
-  }
-
   get isActive() {
     return this.#group.isActive();
   }
@@ -187,4 +181,14 @@ export class WorkerConversation {
   dmPeerInboxId() {
     return this.#group.dmPeerInboxId();
   }
+
+  stream(callback?: StreamCallback<Message>) {
+    const on_message = (message: Message) => {
+      void callback?.(null, message);
+    };
+    const on_error = (error: Error | null) => {
+      void callback?.(error, undefined);
+    };
+    return this.#group.stream({ on_message, on_error });
+  }
 }

package/src/WorkerConversations.ts

@@ -1,4 +1,10 @@
-import type { Conversation, Conversations } from "@xmtp/wasm-bindings";
+import {
+  ConversationType,
+  type Conversation,
+  type Conversations,
+  type Message,
+} from "@xmtp/wasm-bindings";
+import type { StreamCallback } from "@/AsyncStream";
 import {
   fromSafeCreateGroupOptions,
   fromSafeListConversationsOptions,
@@ -94,4 +100,44 @@ export class WorkerConversations {
   getHmacKeys() {
     return this.#conversations.getHmacKeys() as HmacKeys;
   }
+
+  stream(
+    callback?: StreamCallback<Conversation>,
+    conversationType?: ConversationType,
+  ) {
+    const on_conversation = (conversation: Conversation) => {
+      void callback?.(null, conversation);
+    };
+    const on_error = (error: Error | null) => {
+      void callback?.(error, undefined);
+    };
+    return this.#conversations.stream(
+      { on_conversation, on_error },
+      conversationType,
+    );
+  }
+
+  streamGroups(callback?: StreamCallback<Conversation>) {
+    return this.#conversations.stream(callback, ConversationType.Group);
+  }
+
+  streamDms(callback?: StreamCallback<Conversation>) {
+    return this.#conversations.stream(callback, ConversationType.Dm);
+  }
+
+  streamAllMessages(
+    callback?: StreamCallback<Message>,
+    conversationType?: ConversationType,
+  ) {
+    const on_message = (message: Message) => {
+      void callback?.(null, message);
+    };
+    const on_error = (error: Error | null) => {
+      void callback?.(error, undefined);
+    };
+    return this.#conversations.streamAllMessages(
+      { on_message, on_error },
+      conversationType,
+    );
+  }
 }

package/src/types/clientEvents.ts

@@ -1,6 +1,7 @@
 import type {
   ConsentEntityType,
   ConsentState,
+  ConversationType,
   MetadataField,
   PermissionPolicy,
   PermissionUpdateType,
@@ -30,6 +31,17 @@ import type {
 } from "@/utils/conversions";
 
 export type ClientEvents =
+  /**
+   * Stream actions
+   */
+  | {
+      action: "endStream";
+      id: string;
+      result: undefined;
+      data: {
+        streamId: string;
+      };
+    }
   /**
    * Client actions
    */
@@ -283,6 +295,24 @@ export type ClientEvents =
       result: SafeHmacKeys;
       data: undefined;
     }
+  | {
+      action: "streamAllGroups";
+      id: string;
+      result: undefined;
+      data: {
+        streamId: string;
+        conversationType?: ConversationType;
+      };
+    }
+  | {
+      action: "streamAllMessages";
+      id: string;
+      result: undefined;
+      data: {
+        streamId: string;
+        conversationType?: ConversationType;
+      };
+    }
   /**
    * Group actions
    */
@@ -470,15 +500,6 @@ export type ClientEvents =
         imageUrl: string;
       };
     }
-  | {
-      action: "updateGroupPinnedFrameUrl";
-      id: string;
-      result: undefined;
-      data: {
-        id: string;
-        pinnedFrameUrl: string;
-      };
-    }
   | {
       action: "getGroupConsentState";
       id: string;
@@ -522,6 +543,15 @@ export type ClientEvents =
       data: {
         id: string;
       };
+    }
+  | {
+      action: "streamGroupMessages";
+      id: string;
+      result: undefined;
+      data: {
+        groupId: string;
+        streamId: string;
+      };
     };
 
 export type ClientEventsActions = ClientEvents["action"];

package/src/types/clientStreamEvents.ts

@@ -0,0 +1,30 @@
+import type {
+  StreamEventsClientPostMessageData,
+  StreamEventsErrorData,
+  StreamEventsResult,
+} from "@/types";
+import type { SafeConversation, SafeMessage } from "@/utils/conversions";
+
+export type ClientStreamEvents =
+  | {
+      type: "message";
+      streamId: string;
+      result: SafeMessage | undefined;
+    }
+  | {
+      type: "group";
+      streamId: string;
+      result: SafeConversation | undefined;
+    };
+
+export type ClientStreamEventsTypes = ClientStreamEvents["type"];
+
+export type ClientStreamEventsResult<A extends ClientStreamEventsTypes> =
+  StreamEventsResult<ClientStreamEvents, A>;
+
+export type ClientStreamEventsWorkerPostMessageData<
+  A extends ClientStreamEventsTypes,
+> = StreamEventsClientPostMessageData<ClientStreamEvents, A>;
+
+export type ClientStreamEventsErrorData =
+  StreamEventsErrorData<ClientStreamEvents>;

package/src/types/utils.ts

@@ -44,3 +44,29 @@ export type EventsErrorData<Events extends GenericEvent> = {
   action: Events["action"];
   error: string;
 };
+
+export type GenericStreamEvent = {
+  type: string;
+  streamId: string;
+  result: unknown;
+};
+
+export type StreamEventsClientMessageData<Events extends GenericStreamEvent> = {
+  [Type in Events["type"]]: Omit<Extract<Events, { type: Type }>, "result">;
+}[Events["type"]];
+
+export type StreamEventsResult<
+  Events extends GenericStreamEvent,
+  Type extends Events["type"],
+> = Extract<Events, { type: Type }>["result"];
+
+export type StreamEventsClientPostMessageData<
+  Events extends GenericStreamEvent,
+  Type extends Events["type"],
+> = Extract<Events, { type: Type }>;
+
+export type StreamEventsErrorData<Events extends GenericStreamEvent> = {
+  streamId: string;
+  type: Events["type"];
+  error: string;
+};

package/src/utils/conversions.ts

@@ -210,8 +210,7 @@ export type SafePermissionPolicySet = {
   updateGroupDescriptionPolicy: PermissionPolicy;
   updateGroupImageUrlSquarePolicy: PermissionPolicy;
   updateGroupNamePolicy: PermissionPolicy;
-  updateGroupPinnedFrameUrlPolicy: PermissionPolicy;
-  updateMessageExpirationPolicy: PermissionPolicy;
+  updateMessageDisappearingPolicy: PermissionPolicy;
 };
 
 export const toSafePermissionPolicySet = (
@@ -224,8 +223,7 @@ export const toSafePermissionPolicySet = (
   updateGroupDescriptionPolicy: policySet.updateGroupDescriptionPolicy,
   updateGroupImageUrlSquarePolicy: policySet.updateGroupImageUrlSquarePolicy,
   updateGroupNamePolicy: policySet.updateGroupNamePolicy,
-  updateGroupPinnedFrameUrlPolicy: policySet.updateGroupPinnedFrameUrlPolicy,
-  updateMessageExpirationPolicy: policySet.updateMessageExpirationPolicy,
+  updateMessageDisappearingPolicy: policySet.updateMessageDisappearingPolicy,
 });
 
 export const fromSafePermissionPolicySet = (
@@ -239,8 +237,7 @@ export const fromSafePermissionPolicySet = (
     policySet.updateGroupNamePolicy,
     policySet.updateGroupDescriptionPolicy,
     policySet.updateGroupImageUrlSquarePolicy,
-    policySet.updateGroupPinnedFrameUrlPolicy,
-    policySet.updateMessageExpirationPolicy,
+    policySet.updateMessageDisappearingPolicy,
   );
 
 export type SafeCreateGroupOptions = {
@@ -249,7 +246,6 @@ export type SafeCreateGroupOptions = {
   imageUrlSquare?: string;
   name?: string;
   permissions?: GroupPermissionsOptions;
-  pinnedFrameUrl?: string;
 };
 
 export const toSafeCreateGroupOptions = (
@@ -258,7 +254,6 @@ export const toSafeCreateGroupOptions = (
   description: options.groupDescription,
   imageUrlSquare: options.groupImageUrlSquare,
   name: options.groupName,
-  pinnedFrameUrl: options.groupPinnedFrameUrl,
   permissions: options.permissions,
   customPermissionPolicySet: options.customPermissionPolicySet,
 });
@@ -271,7 +266,6 @@ export const fromSafeCreateGroupOptions = (
     options.name,
     options.imageUrlSquare,
     options.description,
-    options.pinnedFrameUrl,
     // only include custom policy set if permissions are set to CustomPolicy
     options.customPermissionPolicySet &&
     options.permissions === GroupPermissionsOptions.CustomPolicy
@@ -284,7 +278,6 @@ export type SafeConversation = {
   name: string;
   imageUrl: string;
   description: string;
-  pinnedFrameUrl: string;
   permissions: {
     policyType: GroupPermissionsOptions;
     policySet: {
@@ -295,8 +288,7 @@ export type SafeConversation = {
       updateGroupDescriptionPolicy: PermissionPolicy;
       updateGroupImageUrlSquarePolicy: PermissionPolicy;
       updateGroupNamePolicy: PermissionPolicy;
-      updateGroupPinnedFrameUrlPolicy: PermissionPolicy;
-      updateMessageExpirationPolicy: PermissionPolicy;
+      updateMessageDisappearingPolicy: PermissionPolicy;
     };
   };
   isActive: boolean;
@@ -317,7 +309,6 @@ export const toSafeConversation = async (
   const name = conversation.name;
   const imageUrl = conversation.imageUrl;
   const description = conversation.description;
-  const pinnedFrameUrl = conversation.pinnedFrameUrl;
   const permissions = conversation.permissions;
   const isActive = conversation.isActive;
   const addedByInboxId = conversation.addedByInboxId;
@@ -332,7 +323,6 @@ export const toSafeConversation = async (
     name,
     imageUrl,
     description,
-    pinnedFrameUrl,
     permissions: {
       policyType,
       policySet: {
@@ -344,9 +334,8 @@ export const toSafeConversation = async (
         updateGroupImageUrlSquarePolicy:
           policySet.updateGroupImageUrlSquarePolicy,
         updateGroupNamePolicy: policySet.updateGroupNamePolicy,
-        updateGroupPinnedFrameUrlPolicy:
-          policySet.updateGroupPinnedFrameUrlPolicy,
-        updateMessageExpirationPolicy: policySet.updateMessageExpirationPolicy,
+        updateMessageDisappearingPolicy:
+          policySet.updateMessageDisappearingPolicy,
       },
     },
     isActive,

package/src/workers/client.ts

@@ -1,9 +1,15 @@
+import type { Conversation, Message, StreamCloser } from "@xmtp/wasm-bindings";
 import type {
   ClientEventsActions,
   ClientEventsClientMessageData,
   ClientEventsErrorData,
   ClientEventsWorkerPostMessageData,
 } from "@/types";
+import type {
+  ClientStreamEventsErrorData,
+  ClientStreamEventsTypes,
+  ClientStreamEventsWorkerPostMessageData,
+} from "@/types/clientStreamEvents";
 import {
   fromEncodedContent,
   fromSafeEncodedContent,
@@ -13,10 +19,13 @@ import {
   toSafeMessage,
 } from "@/utils/conversions";
 import { WorkerClient } from "@/WorkerClient";
+import { WorkerConversation } from "@/WorkerConversation";
 
 let client: WorkerClient;
 let enableLogging = false;
 
+const streamClosers = new Map<string, StreamCloser>();
+
 /**
  * Type-safe postMessage
  */
@@ -33,6 +42,22 @@ const postMessageError = (data: ClientEventsErrorData) => {
   self.postMessage(data);
 };
 
+/**
+ * Type-safe postMessage for streams
+ */
+const postStreamMessage = <A extends ClientStreamEventsTypes>(
+  data: ClientStreamEventsWorkerPostMessageData<A>,
+) => {
+  self.postMessage(data);
+};
+
+/**
+ * Type-safe postMessage for stream errors
+ */
+const postStreamMessageError = (data: ClientStreamEventsErrorData) => {
+  self.postMessage(data);
+};
+
 self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
   const { action, id, data } = event.data;
 
@@ -53,6 +78,28 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
 
   try {
     switch (action) {
+      /**
+       * Stream actions
+       */
+      case "endStream": {
+        const streamCloser = streamClosers.get(data.streamId);
+        if (streamCloser) {
+          streamCloser.end();
+          streamClosers.delete(data.streamId);
+          postMessage({
+            id,
+            action,
+            result: undefined,
+          });
+        } else {
+          postMessageError({
+            id,
+            action,
+            error: `Stream "${data.streamId}" not found`,
+          });
+        }
+        break;
+      }
       /**
        * Client actions
        */
@@ -76,7 +123,7 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
         });
         break;
       case "createInboxSignatureText": {
-        const result = await client.createInboxSignatureText();
+        const result = client.createInboxSignatureText();
         postMessage({
           id,
           action,
@@ -266,6 +313,72 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
       /**
        * Conversations actions
        */
+      case "streamAllGroups": {
+        const streamCallback = async (
+          error: Error | null,
+          value: Conversation | undefined,
+        ) => {
+          if (error) {
+            postStreamMessageError({
+              type: "group",
+              streamId: data.streamId,
+              error: error.message,
+            });
+          } else {
+            postStreamMessage({
+              type: "group",
+              streamId: data.streamId,
+              result: value
+                ? await toSafeConversation(
+                    new WorkerConversation(client, value),
+                  )
+                : undefined,
+            });
+          }
+        };
+        const streamCloser = client.conversations.stream(
+          streamCallback,
+          data.conversationType,
+        );
+        streamClosers.set(data.streamId, streamCloser);
+        postMessage({
+          id,
+          action,
+          result: undefined,
+        });
+        break;
+      }
+      case "streamAllMessages": {
+        const streamCallback = (
+          error: Error | null,
+          value: Message | undefined,
+        ) => {
+          if (error) {
+            postStreamMessageError({
+              type: "message",
+              streamId: data.streamId,
+              error: error.message,
+            });
+          } else {
+            postStreamMessage({
+              type: "message",
+              streamId: data.streamId,
+              result: value ? toSafeMessage(value) : undefined,
+            });
+          }
+        };
+        const streamCloser = client.conversations.streamAllMessages(
+          streamCallback,
+          data.conversationType,
+        );
+        streamClosers.set(data.streamId, streamCloser);
+        postMessage({
+          id,
+          action,
+          result: undefined,
+        });
+        break;
+      }
       case "getConversations": {
         const conversations = client.conversations.list(data.options);
         postMessage({
@@ -466,24 +579,6 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
         }
         break;
       }
-      case "updateGroupPinnedFrameUrl": {
-        const group = client.conversations.getConversationById(data.id);
-        if (group) {
-          await group.updatePinnedFrameUrl(data.pinnedFrameUrl);
-          postMessage({
-            id,
-            action,
-            result: undefined,
-          });
-        } else {
-          postMessageError({
-            id,
-            action,
-            error: "Group not found",
-          });
-        }
-        break;
-      }
       case "sendGroupMessage": {
         const group = client.conversations.getConversationById(data.id);
         if (group) {
@@ -885,6 +980,43 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
         }
         break;
       }
+      case "streamGroupMessages": {
+        const group = client.conversations.getConversationById(data.groupId);
+        if (group) {
+          const streamCallback = (
+            error: Error | null,
+            value: Message | undefined,
+          ) => {
+            if (error) {
+              postStreamMessageError({
+                type: "message",
+                streamId: data.streamId,
+                error: error.message,
+              });
+            } else {
+              postStreamMessage({
+                type: "message",
+                streamId: data.streamId,
+                result: value ? toSafeMessage(value) : undefined,
+              });
+            }
+          };
+          const streamCloser = group.stream(streamCallback);
+          streamClosers.set(data.streamId, streamCloser);
+          postMessage({
+            id,
+            action,
+            result: undefined,
+          });
+        } else {
+          postMessageError({
+            id,
+            action,
+            error: "Group not found",
+          });
+        }
+        break;
+      }
     }
   } catch (e) {
     postMessageError({