@xmtp/browser-sdk 0.0.17 → 0.0.19

package/src/Conversations.ts

@@ -1,9 +1,15 @@
+import { ConversationType, type ConsentState } 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,
+  SafeCreateDmOptions,
   SafeCreateGroupOptions,
   SafeListConversationsOptions,
+  SafeMessage,
 } from "@/utils/conversions";
 
 export class Conversations {
@@ -17,8 +23,10 @@ export class Conversations {
     return this.#client.sendMessage("syncConversations", undefined);
   }
 
-  async syncAll() {
-    return this.#client.sendMessage("syncAllConversations", undefined);
+  async syncAll(consentStates?: ConsentState[]) {
+    return this.#client.sendMessage("syncAllConversations", {
+      consentStates,
+    });
   }
 
   async getConversationById(id: string) {
@@ -88,9 +96,31 @@ export class Conversations {
     return new Conversation(this.#client, conversation.id, conversation);
   }
 
-  async newDm(accountAddress: string) {
+  async newGroupByInboxIds(
+    inboxIds: string[],
+    options?: SafeCreateGroupOptions,
+  ) {
+    const conversation = await this.#client.sendMessage("newGroupByInboxIds", {
+      inboxIds,
+      options,
+    });
+
+    return new Conversation(this.#client, conversation.id, conversation);
+  }
+
+  async newDm(accountAddress: string, options?: SafeCreateDmOptions) {
     const conversation = await this.#client.sendMessage("newDm", {
       accountAddress,
+      options,
+    });
+
+    return new Conversation(this.#client, conversation.id, conversation);
+  }
+
+  async newDmByInboxId(inboxId: string, options?: SafeCreateDmOptions) {
+    const conversation = await this.#client.sendMessage("newDmByInboxId", {
+      inboxId,
+      options,
     });
 
     return new Conversation(this.#client, conversation.id, conversation);
@@ -99,4 +129,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

@@ -1,12 +1,15 @@
-import type {
-  ConsentState,
-  Conversation,
-  EncodedContent,
-  GroupMember,
-  MetadataField,
-  PermissionPolicy,
-  PermissionUpdateType,
+import {
+  MessageDisappearingSettings,
+  type ConsentState,
+  type Conversation,
+  type EncodedContent,
+  type GroupMember,
+  type Message,
+  type MetadataField,
+  type PermissionPolicy,
+  type PermissionUpdateType,
 } from "@xmtp/wasm-bindings";
+import { type StreamCallback } from "@/AsyncStream";
 import {
   fromSafeListMessagesOptions,
   toSafeGroupMember,
@@ -53,14 +56,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 +182,31 @@ export class WorkerConversation {
   dmPeerInboxId() {
     return this.#group.dmPeerInboxId();
   }
+
+  messageDisappearingSettings() {
+    return this.#group.messageDisappearingSettings();
+  }
+
+  async updateMessageDisappearingSettings(fromNs: bigint, inNs: bigint) {
+    const settings = new MessageDisappearingSettings(fromNs, inNs);
+    return this.#group.updateMessageDisappearingSettings(settings);
+  }
+
+  async removeMessageDisappearingSettings() {
+    return this.#group.removeMessageDisappearingSettings();
+  }
+
+  isMessageDisappearingEnabled() {
+    return this.#group.isMessageDisappearingEnabled();
+  }
+
+  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,8 +1,18 @@
-import type { Conversation, Conversations } from "@xmtp/wasm-bindings";
 import {
+  ConversationType,
+  type ConsentState,
+  type Conversation,
+  type ConversationListItem,
+  type Conversations,
+  type Message,
+} from "@xmtp/wasm-bindings";
+import type { StreamCallback } from "@/AsyncStream";
+import {
+  fromSafeCreateDmOptions,
   fromSafeCreateGroupOptions,
   fromSafeListConversationsOptions,
   type HmacKeys,
+  type SafeCreateDmOptions,
   type SafeCreateGroupOptions,
   type SafeListConversationsOptions,
 } from "@/utils/conversions";
@@ -23,8 +33,8 @@ export class WorkerConversations {
     return this.#conversations.sync();
   }
 
-  async syncAll() {
-    return this.#conversations.syncAllConversations();
+  async syncAll(consentStates?: ConsentState[]) {
+    return this.#conversations.syncAllConversations(consentStates);
   }
 
   getConversationById(id: string) {
@@ -58,8 +68,10 @@ export class WorkerConversations {
   list(options?: SafeListConversationsOptions) {
     const groups = this.#conversations.list(
       options ? fromSafeListConversationsOptions(options) : undefined,
-    ) as Conversation[];
-    return groups.map((group) => new WorkerConversation(this.#client, group));
+    ) as ConversationListItem[];
+    return groups.map(
+      (item) => new WorkerConversation(this.#client, item.conversation),
+    );
   }
 
   listGroups(
@@ -67,15 +79,19 @@ export class WorkerConversations {
   ) {
     const groups = this.#conversations.listGroups(
       options ? fromSafeListConversationsOptions(options) : undefined,
-    ) as Conversation[];
-    return groups.map((group) => new WorkerConversation(this.#client, group));
+    ) as ConversationListItem[];
+    return groups.map(
+      (item) => new WorkerConversation(this.#client, item.conversation),
+    );
   }
 
   listDms(options?: Omit<SafeListConversationsOptions, "conversation_type">) {
     const groups = this.#conversations.listDms(
       options ? fromSafeListConversationsOptions(options) : undefined,
-    ) as Conversation[];
-    return groups.map((group) => new WorkerConversation(this.#client, group));
+    ) as ConversationListItem[];
+    return groups.map(
+      (item) => new WorkerConversation(this.#client, item.conversation),
+    );
   }
 
   async newGroup(accountAddresses: string[], options?: SafeCreateGroupOptions) {
@@ -86,12 +102,74 @@ export class WorkerConversations {
     return new WorkerConversation(this.#client, group);
   }
 
-  async newDm(accountAddress: string) {
-    const group = await this.#conversations.createDm(accountAddress);
+  async newGroupByInboxIds(
+    inboxIds: string[],
+    options?: SafeCreateGroupOptions,
+  ) {
+    const group = await this.#conversations.createGroupByInboxIds(
+      inboxIds,
+      options ? fromSafeCreateGroupOptions(options) : undefined,
+    );
+    return new WorkerConversation(this.#client, group);
+  }
+
+  async newDm(accountAddress: string, options?: SafeCreateDmOptions) {
+    const group = await this.#conversations.createDm(
+      accountAddress,
+      options ? fromSafeCreateDmOptions(options) : undefined,
+    );
+    return new WorkerConversation(this.#client, group);
+  }
+
+  async newDmByInboxId(inboxId: string, options?: SafeCreateDmOptions) {
+    const group = await this.#conversations.createDmByInboxId(
+      inboxId,
+      options ? fromSafeCreateDmOptions(options) : undefined,
+    );
     return new WorkerConversation(this.#client, group);
   }
 
   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,
@@ -19,6 +20,7 @@ import type {
 import type {
   SafeConsent,
   SafeConversation,
+  SafeCreateDmOptions,
   SafeCreateGroupOptions,
   SafeEncodedContent,
   SafeGroupMember,
@@ -27,9 +29,21 @@ import type {
   SafeListConversationsOptions,
   SafeListMessagesOptions,
   SafeMessage,
+  SafeMessageDisappearingSettings,
 } from "@/utils/conversions";
 
 export type ClientEvents =
+  /**
+   * Stream actions
+   */
+  | {
+      action: "endStream";
+      id: string;
+      result: undefined;
+      data: {
+        streamId: string;
+      };
+    }
   /**
    * Client actions
    */
@@ -257,12 +271,31 @@ export type ClientEvents =
         options?: SafeCreateGroupOptions;
       };
     }
+  | {
+      action: "newGroupByInboxIds";
+      id: string;
+      result: SafeConversation;
+      data: {
+        inboxIds: string[];
+        options?: SafeCreateGroupOptions;
+      };
+    }
   | {
       action: "newDm";
       id: string;
       result: SafeConversation;
       data: {
         accountAddress: string;
+        options?: SafeCreateDmOptions;
+      };
+    }
+  | {
+      action: "newDmByInboxId";
+      id: string;
+      result: SafeConversation;
+      data: {
+        inboxId: string;
+        options?: SafeCreateDmOptions;
       };
     }
   | {
@@ -275,7 +308,9 @@ export type ClientEvents =
       action: "syncAllConversations";
       id: string;
       result: undefined;
-      data: undefined;
+      data: {
+        consentStates?: ConsentState[];
+      };
     }
   | {
       action: "getHmacKeys";
@@ -283,6 +318,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 +523,6 @@ export type ClientEvents =
         imageUrl: string;
       };
     }
-  | {
-      action: "updateGroupPinnedFrameUrl";
-      id: string;
-      result: undefined;
-      data: {
-        id: string;
-        pinnedFrameUrl: string;
-      };
-    }
   | {
       action: "getGroupConsentState";
       id: string;
@@ -522,6 +566,47 @@ export type ClientEvents =
       data: {
         id: string;
       };
+    }
+  | {
+      action: "getGroupMessageDisappearingSettings";
+      id: string;
+      result: SafeMessageDisappearingSettings | undefined;
+      data: {
+        id: string;
+      };
+    }
+  | {
+      action: "updateGroupMessageDisappearingSettings";
+      id: string;
+      result: undefined;
+      data: SafeMessageDisappearingSettings & {
+        id: string;
+      };
+    }
+  | {
+      action: "removeGroupMessageDisappearingSettings";
+      id: string;
+      result: undefined;
+      data: {
+        id: string;
+      };
+    }
+  | {
+      action: "isGroupMessageDisappearingEnabled";
+      id: string;
+      result: boolean;
+      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;
+};