@xmtp/browser-sdk 5.2.0 → 6.0.0

package/src/Preferences.ts

@@ -1,72 +1,85 @@
-import type { ConsentEntityType, UserPreference } from "@xmtp/wasm-bindings";
-import { v4 } from "uuid";
-import type { SafeConsent } from "@/utils/conversions";
+import type {
+  Consent,
+  ConsentEntityType,
+  ConsentState,
+  UserPreferenceUpdate,
+} from "@xmtp/wasm-bindings";
+import type { ClientWorkerAction } from "@/types/actions";
 import {
   createStream,
   type StreamCallback,
   type StreamOptions,
 } from "@/utils/streams";
-import type { Client } from "./Client";
+import { uuid } from "@/utils/uuid";
+import type { WorkerBridge } from "@/utils/WorkerBridge";
 
 /**
  * Manages user preferences and consent states
  *
  * This class is not intended to be initialized directly.
  */
-export class Preferences<ContentTypes = unknown> {
-  #client: Client<ContentTypes>;
+export class Preferences {
+  #worker: WorkerBridge<ClientWorkerAction>;
 
   /**
    * Creates a new preferences instance
    *
    * @param client - The client instance managing preferences
    */
-  constructor(client: Client<ContentTypes>) {
-    this.#client = client;
+  constructor(worker: WorkerBridge<ClientWorkerAction>) {
+    this.#worker = worker;
   }
 
   sync() {
-    return this.#client.sendMessage("preferences.sync", undefined);
+    return this.#worker.action("preferences.sync");
   }
 
   /**
-   * Retrieves the current inbox state
+   * Retrieves the current inbox state of this client from the local database
    *
-   * @param refreshFromNetwork - Optional flag to force refresh from network
    * @returns Promise that resolves with the inbox state
    */
-  async inboxState(refreshFromNetwork?: boolean) {
-    return this.#client.sendMessage("preferences.inboxState", {
-      refreshFromNetwork: refreshFromNetwork ?? false,
+  async inboxState() {
+    return this.#worker.action("preferences.inboxState", {
+      refreshFromNetwork: false,
     });
   }
 
   /**
-   * Retrieves inbox state for specific inbox IDs
+   * Retrieves the latest inbox state of this client from the network
+   *
+   * @returns Promise that resolves with the inbox state
+   */
+  async fetchInboxState() {
+    return this.#worker.action("preferences.inboxState", {
+      refreshFromNetwork: true,
+    });
+  }
+
+  /**
+   * Retrieves the current inbox states for specified inbox IDs from the local
+   * database
    *
    * @param inboxIds - Array of inbox IDs to get state for
-   * @param refreshFromNetwork - Optional flag to force refresh from network
-   * @returns Promise that resolves with the inbox state for the inbox IDs
+   * @returns Promise that resolves with the inbox states for the inbox IDs
    */
-  async inboxStateFromInboxIds(
-    inboxIds: string[],
-    refreshFromNetwork?: boolean,
-  ) {
-    return this.#client.sendMessage("preferences.inboxStateFromInboxIds", {
+  async getInboxStates(inboxIds: string[]) {
+    return this.#worker.action("preferences.getInboxStates", {
       inboxIds,
-      refreshFromNetwork: refreshFromNetwork ?? false,
+      refreshFromNetwork: false,
     });
   }
 
   /**
-   * Gets the latest inbox state for a specific inbox
+   * Retrieves the latest inbox states for specified inbox IDs from the network
    *
-   * @param inboxId - The inbox ID to get state for
-   * @returns Promise that resolves with the latest inbox state
+   * @param inboxIds - Array of inbox IDs to get state for
+   * @returns Promise that resolves with the inbox states for the inbox IDs
    */
-  async getLatestInboxState(inboxId: string) {
-    return this.#client.sendMessage("preferences.getLatestInboxState", {
-      inboxId,
+  async fetchInboxStates(inboxIds: string[]) {
+    return this.#worker.action("preferences.getInboxStates", {
+      inboxIds,
+      refreshFromNetwork: true,
     });
   }
 
@@ -76,8 +89,8 @@ export class Preferences<ContentTypes = unknown> {
    * @param records - Array of consent records to update
    * @returns Promise that resolves when consent states are updated
    */
-  async setConsentStates(records: SafeConsent[]) {
-    return this.#client.sendMessage("preferences.setConsentStates", {
+  async setConsentStates(records: Consent[]) {
+    return this.#worker.action("preferences.setConsentStates", {
       records,
     });
   }
@@ -89,8 +102,11 @@ export class Preferences<ContentTypes = unknown> {
    * @param entity - Entity identifier
    * @returns Promise that resolves with the consent state
    */
-  async getConsentState(entityType: ConsentEntityType, entity: string) {
-    return this.#client.sendMessage("preferences.getConsentState", {
+  async getConsentState(
+    entityType: ConsentEntityType,
+    entity: string,
+  ): Promise<ConsentState> {
+    return this.#worker.action("preferences.getConsentState", {
       entityType,
       entity,
     });
@@ -102,27 +118,25 @@ export class Preferences<ContentTypes = unknown> {
    * @param options - Optional stream options
    * @returns Stream instance for consent updates
    */
-  async streamConsent(options?: StreamOptions<SafeConsent[]>) {
+  async streamConsent(options?: StreamOptions<Consent[]>) {
     const stream = async (
-      callback: StreamCallback<SafeConsent[]>,
+      callback: StreamCallback<Consent[]>,
       onFail: () => void,
     ) => {
-      const streamId = v4();
+      const streamId = uuid();
       // sync the conversation
-      await this.sync();
+      if (!options?.disableSync) {
+        await this.sync();
+      }
       // start the stream
-      await this.#client.sendMessage("preferences.streamConsent", {
+      await this.#worker.action("preferences.streamConsent", {
         streamId,
       });
       // handle stream messages
-      return this.#client.handleStreamMessage<SafeConsent[]>(
-        streamId,
-        callback,
-        {
-          ...options,
-          onFail,
-        },
-      );
+      return this.#worker.handleStreamMessage<Consent[]>(streamId, callback, {
+        ...options,
+        onFail,
+      });
     };
 
     return createStream(stream, undefined, options);
@@ -134,20 +148,22 @@ export class Preferences<ContentTypes = unknown> {
    * @param options - Optional stream options
    * @returns Stream instance for preference updates
    */
-  async streamPreferences(options?: StreamOptions<UserPreference[]>) {
+  async streamPreferences(options?: StreamOptions<UserPreferenceUpdate[]>) {
     const stream = async (
-      callback: StreamCallback<UserPreference[]>,
+      callback: StreamCallback<UserPreferenceUpdate[]>,
       onFail: () => void,
     ) => {
-      const streamId = v4();
+      const streamId = uuid();
       // sync the conversation
-      await this.sync();
+      if (!options?.disableSync) {
+        await this.sync();
+      }
       // start the stream
-      await this.#client.sendMessage("preferences.streamPreferences", {
+      await this.#worker.action("preferences.streamPreferences", {
         streamId,
       });
       // handle stream messages
-      return this.#client.handleStreamMessage<UserPreference[]>(
+      return this.#worker.handleStreamMessage<UserPreferenceUpdate[]>(
         streamId,
         callback,
         {

package/src/WorkerClient.ts

@@ -18,11 +18,11 @@ export class WorkerClient {
   #debugInformation: WorkerDebugInformation;
   #preferences: WorkerPreferences;
 
-  constructor(client: Client, options?: ClientOptions) {
+  constructor(client: Client) {
     this.#client = client;
     const conversations = client.conversations();
     this.#conversations = new WorkerConversations(this, conversations);
-    this.#debugInformation = new WorkerDebugInformation(client, options);
+    this.#debugInformation = new WorkerDebugInformation(client);
     this.#preferences = new WorkerPreferences(client, conversations);
   }
 
@@ -31,7 +31,7 @@ export class WorkerClient {
     options?: Omit<ClientOptions, "codecs">,
   ) {
     const client = await createClient(identifier, options);
-    return new WorkerClient(client, options);
+    return new WorkerClient(client);
   }
 
   get libxmtpVersion() {
@@ -143,7 +143,7 @@ export class WorkerClient {
     await this.#client.registerIdentity(signatureRequest);
   }
 
-  async findInboxIdByIdentifier(identifier: Identifier) {
+  async getInboxIdByIdentifier(identifier: Identifier) {
     return this.#client.findInboxIdByIdentifier(identifier);
   }
 
@@ -179,7 +179,7 @@ export class WorkerClient {
     }
   }
 
-  async getKeyPackageStatusesForInstallationIds(installationIds: string[]) {
+  async fetchKeyPackageStatuses(installationIds: string[]) {
     return this.#client.getKeyPackageStatusesForInstallationIds(
       installationIds,
     ) as Promise<Map<string, KeyPackageStatus>>;

package/src/WorkerConversation.ts

@@ -1,40 +1,42 @@
 import {
-  MessageDisappearingSettings,
+  GroupMembershipState,
   SortDirection,
+  type Actions,
+  type Attachment,
   type ConsentState,
   type Conversation,
   type ConversationDebugInfo,
+  type DecodedMessage,
   type EncodedContent,
   type GroupMember,
   type HmacKey,
   type Identifier,
+  type Intent,
+  type ListMessagesOptions,
   type Message,
+  type MessageDisappearingSettings,
   type MetadataField,
+  type MultiRemoteAttachment,
   type PermissionPolicy,
   type PermissionUpdateType,
+  type Reaction,
+  type RemoteAttachment,
+  type Reply,
   type SendMessageOpts,
+  type TransactionReference,
+  type WalletSendCalls,
 } from "@xmtp/wasm-bindings";
-import {
-  fromSafeListMessagesOptions,
-  toSafeGroupMember,
-  type SafeListMessagesOptions,
-} from "@/utils/conversions";
+import type { LastReadTimes } from "@/utils/conversions";
 import type { StreamCallback } from "@/utils/streams";
 import type { WorkerClient } from "@/WorkerClient";
 
 export class WorkerConversation {
   #client: WorkerClient;
   #group: Conversation;
-  #isCommitLogForked?: boolean;
 
-  constructor(
-    client: WorkerClient,
-    group: Conversation,
-    isCommitLogForked?: boolean,
-  ) {
+  constructor(client: WorkerClient, group: Conversation) {
     this.#client = client;
     this.#group = group;
-    this.#isCommitLogForked = isCommitLogForked;
   }
 
   get id() {
@@ -65,12 +67,21 @@ export class WorkerConversation {
     return this.#group.updateGroupDescription(description);
   }
 
-  get isActive() {
-    return this.#group.isActive();
+  get appData() {
+    try {
+      return this.#group.appData();
+    } catch {
+      // DM groups don't support appData
+      return "";
+    }
   }
 
-  get isCommitLogForked() {
-    return this.#isCommitLogForked;
+  async updateAppData(appData: string) {
+    return this.#group.updateAppData(appData);
+  }
+
+  get isActive() {
+    return this.#group.isActive();
   }
 
   get addedByInboxId() {
@@ -93,31 +104,27 @@ export class WorkerConversation {
   }
 
   async metadata() {
-    const metadata = await this.#group.groupMetadata();
-    return {
-      creatorInboxId: metadata.creatorInboxId(),
-      conversationType: metadata.conversationType(),
-    };
+    return this.#group.groupMetadata();
   }
 
   async members() {
     const members = (await this.#group.listMembers()) as GroupMember[];
-    return members.map((member) => toSafeGroupMember(member));
+    return members;
   }
 
-  get admins() {
+  listAdmins() {
     return this.#group.adminList();
   }
 
-  get superAdmins() {
+  listSuperAdmins() {
     return this.#group.superAdminList();
   }
 
-  get permissions() {
+  permissions() {
     const permissions = this.#group.groupPermissions();
     return {
-      policyType: permissions.policyType(),
-      policySet: permissions.policySet(),
+      policyType: permissions.policyType,
+      policySet: permissions.policySet,
     };
   }
 
@@ -181,29 +188,85 @@ export class WorkerConversation {
     return this.#group.publishMessages();
   }
 
-  sendOptimistic(encodedContent: EncodedContent, opts: SendMessageOpts) {
-    // Pass through to underlying implementation - it will handle undefined opts
-    return this.#group.sendOptimistic(encodedContent, opts);
+  async send(encodedContent: EncodedContent, opts?: SendMessageOpts) {
+    return this.#group.send(encodedContent, opts ?? { shouldPush: true });
   }
 
-  async send(encodedContent: EncodedContent, opts: SendMessageOpts) {
-    // Pass through to underlying implementation - it will handle undefined opts
-    return this.#group.send(encodedContent, opts);
+  async sendText(text: string, isOptimistic?: boolean) {
+    return this.#group.sendText(text, isOptimistic);
   }
 
-  async messages(options?: SafeListMessagesOptions) {
-    return this.#group.findMessages(
-      options ? fromSafeListMessagesOptions(options) : undefined,
+  async sendMarkdown(markdown: string, isOptimistic?: boolean) {
+    return this.#group.sendMarkdown(markdown, isOptimistic);
+  }
+
+  async sendReaction(reaction: Reaction, isOptimistic?: boolean) {
+    return this.#group.sendReaction(reaction, isOptimistic);
+  }
+
+  async sendReadReceipt(isOptimistic?: boolean) {
+    return this.#group.sendReadReceipt(isOptimistic);
+  }
+
+  async sendReply(reply: Reply, isOptimistic?: boolean) {
+    return this.#group.sendReply(reply, isOptimistic);
+  }
+
+  async sendTransactionReference(
+    transactionReference: TransactionReference,
+    isOptimistic?: boolean,
+  ) {
+    return this.#group.sendTransactionReference(
+      transactionReference,
+      isOptimistic,
     );
   }
 
-  async countMessages(options?: SafeListMessagesOptions) {
-    return this.#group.countMessages(
-      options ? fromSafeListMessagesOptions(options) : undefined,
+  async sendWalletSendCalls(
+    walletSendCalls: WalletSendCalls,
+    isOptimistic?: boolean,
+  ) {
+    return this.#group.sendWalletSendCalls(walletSendCalls, isOptimistic);
+  }
+
+  async sendActions(actions: Actions, isOptimistic?: boolean) {
+    return this.#group.sendActions(actions, isOptimistic);
+  }
+
+  async sendIntent(intent: Intent, isOptimistic?: boolean) {
+    return this.#group.sendIntent(intent, isOptimistic);
+  }
+
+  async sendAttachment(attachment: Attachment, isOptimistic?: boolean) {
+    return this.#group.sendAttachment(attachment, isOptimistic);
+  }
+
+  async sendMultiRemoteAttachment(
+    multiRemoteAttachment: MultiRemoteAttachment,
+    isOptimistic?: boolean,
+  ) {
+    return this.#group.sendMultiRemoteAttachment(
+      multiRemoteAttachment,
+      isOptimistic,
     );
   }
 
-  get consentState() {
+  async sendRemoteAttachment(
+    remoteAttachment: RemoteAttachment,
+    isOptimistic?: boolean,
+  ) {
+    return this.#group.sendRemoteAttachment(remoteAttachment, isOptimistic);
+  }
+
+  async messages(options?: ListMessagesOptions): Promise<DecodedMessage[]> {
+    return this.#group.findEnrichedMessages(options);
+  }
+
+  async countMessages(options?: ListMessagesOptions) {
+    return this.#group.countMessages(options);
+  }
+
+  consentState() {
     return this.#group.consentState();
   }
 
@@ -220,7 +283,7 @@ export class WorkerConversation {
   }
 
   async updateMessageDisappearingSettings(fromNs: bigint, inNs: bigint) {
-    const settings = new MessageDisappearingSettings(fromNs, inNs);
+    const settings: MessageDisappearingSettings = { fromNs, inNs };
     return this.#group.updateMessageDisappearingSettings(settings);
   }
 
@@ -249,7 +312,7 @@ export class WorkerConversation {
     return this.#group.pausedForVersion();
   }
 
-  getHmacKeys() {
+  hmacKeys() {
     return this.#group.getHmacKeys() as Map<string, HmacKey[]>;
   }
 
@@ -257,8 +320,20 @@ export class WorkerConversation {
     return (await this.#group.getDebugInfo()) as ConversationDebugInfo;
   }
 
-  async getDuplicateDms() {
+  async duplicateDms() {
     const dms = await this.#group.findDuplicateDms();
     return dms.map((dm) => new WorkerConversation(this.#client, dm));
   }
+
+  async requestRemoval() {
+    return this.#group.leaveGroup();
+  }
+
+  isPendingRemoval() {
+    return this.#group.membershipState() === GroupMembershipState.PendingRemove;
+  }
+
+  async lastReadTimes() {
+    return this.#group.getLastReadTimes() as Promise<LastReadTimes>;
+  }
 }

package/src/WorkerConversations.ts

@@ -4,18 +4,14 @@ import {
   type Conversation,
   type ConversationListItem,
   type Conversations,
+  type CreateDmOptions,
+  type CreateGroupOptions,
+  type DecodedMessage,
   type Identifier,
+  type ListConversationsOptions,
   type Message,
 } from "@xmtp/wasm-bindings";
-import {
-  fromSafeCreateDmOptions,
-  fromSafeCreateGroupOptions,
-  fromSafeListConversationsOptions,
-  type HmacKeys,
-  type SafeCreateDmOptions,
-  type SafeCreateGroupOptions,
-  type SafeListConversationsOptions,
-} from "@/utils/conversions";
+import { type HmacKeys } from "@/utils/conversions";
 import type { StreamCallback } from "@/utils/streams";
 import type { WorkerClient } from "@/WorkerClient";
 import { WorkerConversation } from "@/WorkerConversation";
@@ -48,10 +44,9 @@ export class WorkerConversations {
     }
   }
 
-  getMessageById(id: string) {
+  async getMessageById(id: string): Promise<DecodedMessage | undefined> {
     try {
-      // findMessageById will throw if message is not found
-      return this.#conversations.findMessageById(id);
+      return await this.#conversations.findEnrichedMessageById(id);
     } catch {
       return undefined;
     }
@@ -66,102 +61,68 @@ export class WorkerConversations {
     }
   }
 
-  list(options?: SafeListConversationsOptions) {
-    const groups = this.#conversations.list(
-      options ? fromSafeListConversationsOptions(options) : undefined,
-    ) as ConversationListItem[];
+  list(options?: ListConversationsOptions) {
+    const groups = this.#conversations.list(options) as ConversationListItem[];
     return groups.map(
-      (item) =>
-        new WorkerConversation(
-          this.#client,
-          item.conversation,
-          item.isCommitLogForked,
-        ),
+      (item) => new WorkerConversation(this.#client, item.conversation),
     );
   }
 
-  listGroups(
-    options?: Omit<SafeListConversationsOptions, "conversation_type">,
-  ) {
-    const groups = this.#conversations.list(
-      fromSafeListConversationsOptions({
-        ...(options ?? {}),
-        conversationType: ConversationType.Group,
-      }),
-    ) as ConversationListItem[];
+  listGroups(options?: Omit<ListConversationsOptions, "conversationType">) {
+    const groups = this.#conversations.list({
+      ...(options ?? {}),
+      conversationType: ConversationType.Group,
+    }) as ConversationListItem[];
     return groups.map(
-      (item) =>
-        new WorkerConversation(
-          this.#client,
-          item.conversation,
-          item.isCommitLogForked,
-        ),
+      (item) => new WorkerConversation(this.#client, item.conversation),
     );
   }
 
-  listDms(options?: Omit<SafeListConversationsOptions, "conversation_type">) {
-    const groups = this.#conversations.list(
-      fromSafeListConversationsOptions({
-        ...(options ?? {}),
-        conversationType: ConversationType.Dm,
-      }),
-    ) as ConversationListItem[];
+  listDms(options?: Omit<ListConversationsOptions, "conversationType">) {
+    const groups = this.#conversations.list({
+      ...(options ?? {}),
+      conversationType: ConversationType.Dm,
+    }) as ConversationListItem[];
     return groups.map(
-      (item) =>
-        new WorkerConversation(
-          this.#client,
-          item.conversation,
-          item.isCommitLogForked,
-        ),
+      (item) => new WorkerConversation(this.#client, item.conversation),
     );
   }
 
-  newGroupOptimistic(options?: SafeCreateGroupOptions) {
-    const group = this.#conversations.createGroupOptimistic(
-      options ? fromSafeCreateGroupOptions(options) : undefined,
-    );
+  createGroupOptimistic(options?: CreateGroupOptions) {
+    const group = this.#conversations.createGroupOptimistic(options);
     return new WorkerConversation(this.#client, group);
   }
 
-  async newGroupWithIdentifiers(
+  async createGroupWithIdentifiers(
     identifiers: Identifier[],
-    options?: SafeCreateGroupOptions,
+    options?: CreateGroupOptions,
   ) {
-    const group = await this.#conversations.createGroup(
-      identifiers,
-      options ? fromSafeCreateGroupOptions(options) : undefined,
-    );
+    const group = await this.#conversations.createGroup(identifiers, options);
     return new WorkerConversation(this.#client, group);
   }
 
-  async newGroup(inboxIds: string[], options?: SafeCreateGroupOptions) {
+  async createGroup(inboxIds: string[], options?: CreateGroupOptions) {
     const group = await this.#conversations.createGroupByInboxIds(
       inboxIds,
-      options ? fromSafeCreateGroupOptions(options) : undefined,
+      options,
     );
     return new WorkerConversation(this.#client, group);
   }
 
-  async newDmWithIdentifier(
+  async createDmWithIdentifier(
     identifier: Identifier,
-    options?: SafeCreateDmOptions,
+    options?: CreateDmOptions,
   ) {
-    const group = await this.#conversations.createDm(
-      identifier,
-      options ? fromSafeCreateDmOptions(options) : undefined,
-    );
+    const group = await this.#conversations.createDm(identifier, options);
     return new WorkerConversation(this.#client, group);
   }
 
-  async newDm(inboxId: string, options?: SafeCreateDmOptions) {
-    const group = await this.#conversations.createDmByInboxId(
-      inboxId,
-      options ? fromSafeCreateDmOptions(options) : undefined,
-    );
+  async createDm(inboxId: string, options?: CreateDmOptions) {
+    const group = await this.#conversations.createDmByInboxId(inboxId, options);
     return new WorkerConversation(this.#client, group);
   }
 
-  getHmacKeys() {
+  hmacKeys() {
     return this.#conversations.getHmacKeys() as HmacKeys;
   }