@xmtp/browser-sdk 0.0.20 → 0.0.22

package/src/Conversations.ts

@@ -1,10 +1,16 @@
-import { ConversationType, type ConsentState } from "@xmtp/wasm-bindings";
+import {
+  ConversationType,
+  type ConsentState,
+  type UserPreference,
+} 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 { Dm } from "@/Dm";
+import { Group } from "@/Group";
 import type {
+  SafeConsent,
   SafeConversation,
   SafeCreateDmOptions,
   SafeCreateGroupOptions,
@@ -33,7 +39,12 @@ export class Conversations {
     const data = await this.#client.sendMessage("getConversationById", {
       id,
     });
-    return data ? new Conversation(this.#client, id, data) : undefined;
+    if (data) {
+      return data.metadata.conversationType === "group"
+        ? new Group(this.#client, data.id, data)
+        : new Dm(this.#client, data.id, data);
+    }
+    return undefined;
   }
 
   async getMessageById(id: string) {
@@ -47,7 +58,7 @@ export class Conversations {
     const data = await this.#client.sendMessage("getDmByInboxId", {
       inboxId,
     });
-    return data ? new Conversation(this.#client, data.id, data) : undefined;
+    return data ? new Dm(this.#client, data.id, data) : undefined;
   }
 
   async list(options?: SafeListConversationsOptions) {
@@ -55,9 +66,10 @@ export class Conversations {
       options,
     });
 
-    return conversations.map(
-      (conversation) =>
-        new Conversation(this.#client, conversation.id, conversation),
+    return conversations.map((conversation) =>
+      conversation.metadata.conversationType === "group"
+        ? new Group(this.#client, conversation.id, conversation)
+        : new Dm(this.#client, conversation.id, conversation),
     );
   }
 
@@ -69,8 +81,7 @@ export class Conversations {
     });
 
     return conversations.map(
-      (conversation) =>
-        new Conversation(this.#client, conversation.id, conversation),
+      (conversation) => new Group(this.#client, conversation.id, conversation),
     );
   }
 
@@ -82,8 +93,7 @@ export class Conversations {
     });
 
     return conversations.map(
-      (conversation) =>
-        new Conversation(this.#client, conversation.id, conversation),
+      (conversation) => new Dm(this.#client, conversation.id, conversation),
     );
   }
 
@@ -93,7 +103,7 @@ export class Conversations {
       options,
     });
 
-    return new Conversation(this.#client, conversation.id, conversation);
+    return new Group(this.#client, conversation.id, conversation);
   }
 
   async newGroupByInboxIds(
@@ -105,7 +115,7 @@ export class Conversations {
       options,
     });
 
-    return new Conversation(this.#client, conversation.id, conversation);
+    return new Group(this.#client, conversation.id, conversation);
   }
 
   async newDm(accountAddress: string, options?: SafeCreateDmOptions) {
@@ -114,7 +124,7 @@ export class Conversations {
       options,
     });
 
-    return new Conversation(this.#client, conversation.id, conversation);
+    return new Dm(this.#client, conversation.id, conversation);
   }
 
   async newDmByInboxId(inboxId: string, options?: SafeCreateDmOptions) {
@@ -123,27 +133,39 @@ export class Conversations {
       options,
     });
 
-    return new Conversation(this.#client, conversation.id, conversation);
+    return new Dm(this.#client, conversation.id, conversation);
   }
 
   async getHmacKeys() {
     return this.#client.sendMessage("getHmacKeys", undefined);
   }
 
-  async stream(
-    callback?: StreamCallback<Conversation>,
+  async stream<T extends Group | Dm = Group | Dm>(
+    callback?: StreamCallback<T>,
     conversationType?: ConversationType,
   ) {
     const streamId = v4();
-    const asyncStream = new AsyncStream<Conversation>();
+    const asyncStream = new AsyncStream<T>();
     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);
+        if (error) {
+          void asyncStream.callback(error, undefined);
+          void callback?.(error, undefined);
+          return;
+        }
+
+        let streamValue: T | undefined = undefined;
+
+        if (value) {
+          streamValue =
+            value.metadata.conversationType === "group"
+              ? (new Group(this.#client, value.id, value) as T)
+              : (new Dm(this.#client, value.id, value) as T);
+        }
+
+        void asyncStream.callback(null, streamValue);
+        void callback?.(null, streamValue);
       },
     );
     await this.#client.sendMessage("streamAllGroups", {
@@ -159,12 +181,12 @@ export class Conversations {
     return asyncStream;
   }
 
-  async streamGroups(callback?: StreamCallback<Conversation>) {
-    return this.stream(callback, ConversationType.Group);
+  async streamGroups(callback?: StreamCallback<Group>) {
+    return this.stream<Group>(callback, ConversationType.Group);
   }
 
-  async streamDms(callback?: StreamCallback<Conversation>) {
-    return this.stream(callback, ConversationType.Dm);
+  async streamDms(callback?: StreamCallback<Dm>) {
+    return this.stream<Dm>(callback, ConversationType.Dm);
   }
 
   async streamAllMessages(
@@ -176,11 +198,17 @@ export class Conversations {
     const endStream = this.#client.handleStreamMessage<SafeMessage>(
       streamId,
       (error, value) => {
+        if (error) {
+          void asyncStream.callback(error, undefined);
+          void callback?.(error, undefined);
+          return;
+        }
+
         const decodedMessage = value
           ? new DecodedMessage(this.#client, value)
           : undefined;
-        void asyncStream.callback(error, decodedMessage);
-        void callback?.(error, decodedMessage);
+        void asyncStream.callback(null, decodedMessage);
+        void callback?.(null, decodedMessage);
       },
     );
     await this.#client.sendMessage("streamAllMessages", {
@@ -203,4 +231,48 @@ export class Conversations {
   async streamAllDmMessages(callback?: StreamCallback<DecodedMessage>) {
     return this.streamAllMessages(callback, ConversationType.Dm);
   }
+
+  async streamConsent(callback?: StreamCallback<SafeConsent[]>) {
+    const streamId = v4();
+    const asyncStream = new AsyncStream<SafeConsent[]>();
+    const endStream = this.#client.handleStreamMessage<SafeConsent[]>(
+      streamId,
+      (error, value) => {
+        void asyncStream.callback(error, value ?? undefined);
+        void callback?.(error, value ?? undefined);
+      },
+    );
+    await this.#client.sendMessage("streamConsent", {
+      streamId,
+    });
+    asyncStream.onReturn = () => {
+      void this.#client.sendMessage("endStream", {
+        streamId,
+      });
+      endStream();
+    };
+    return asyncStream;
+  }
+
+  async streamPreferences(callback?: StreamCallback<UserPreference[]>) {
+    const streamId = v4();
+    const asyncStream = new AsyncStream<UserPreference[]>();
+    const endStream = this.#client.handleStreamMessage<UserPreference[]>(
+      streamId,
+      (error, value) => {
+        void asyncStream.callback(error, value ?? undefined);
+        void callback?.(error, value ?? undefined);
+      },
+    );
+    await this.#client.sendMessage("streamPreferences", {
+      streamId,
+    });
+    asyncStream.onReturn = () => {
+      void this.#client.sendMessage("endStream", {
+        streamId,
+      });
+      endStream();
+    };
+    return asyncStream;
+  }
 }

package/src/Dm.ts

@@ -0,0 +1,21 @@
+import type { Client } from "@/Client";
+import { Conversation } from "@/Conversation";
+import type { SafeConversation } from "@/utils/conversions";
+
+export class Dm extends Conversation {
+  #client: Client;
+
+  #id: string;
+
+  constructor(client: Client, id: string, data?: SafeConversation) {
+    super(client, id, data);
+    this.#client = client;
+    this.#id = id;
+  }
+
+  async peerInboxId() {
+    return this.#client.sendMessage("getDmPeerInboxId", {
+      id: this.#id,
+    });
+  }
+}

package/src/Group.ts

@@ -0,0 +1,190 @@
+import type {
+  MetadataField,
+  PermissionPolicy,
+  PermissionUpdateType,
+} from "@xmtp/wasm-bindings";
+import type { Client } from "@/Client";
+import { Conversation } from "@/Conversation";
+import type { SafeConversation } from "@/utils/conversions";
+
+export class Group extends Conversation {
+  #client: Client;
+
+  #id: string;
+
+  #name?: SafeConversation["name"];
+
+  #imageUrl?: SafeConversation["imageUrl"];
+
+  #description?: SafeConversation["description"];
+
+  #admins: SafeConversation["admins"] = [];
+
+  #superAdmins: SafeConversation["superAdmins"] = [];
+
+  #syncData(data?: SafeConversation) {
+    this.#name = data?.name ?? "";
+    this.#imageUrl = data?.imageUrl ?? "";
+    this.#description = data?.description ?? "";
+    this.#admins = data?.admins ?? [];
+    this.#superAdmins = data?.superAdmins ?? [];
+  }
+
+  constructor(client: Client, id: string, data?: SafeConversation) {
+    super(client, id, data);
+    this.#client = client;
+    this.#id = id;
+    this.#syncData(data);
+  }
+
+  async sync() {
+    const data = await super.sync();
+    this.#syncData(data);
+    return data;
+  }
+
+  get name() {
+    return this.#name;
+  }
+
+  async updateName(name: string) {
+    await this.#client.sendMessage("updateGroupName", {
+      id: this.#id,
+      name,
+    });
+    this.#name = name;
+  }
+
+  get imageUrl() {
+    return this.#imageUrl;
+  }
+
+  async updateImageUrl(imageUrl: string) {
+    await this.#client.sendMessage("updateGroupImageUrlSquare", {
+      id: this.#id,
+      imageUrl,
+    });
+    this.#imageUrl = imageUrl;
+  }
+
+  get description() {
+    return this.#description;
+  }
+
+  async updateDescription(description: string) {
+    await this.#client.sendMessage("updateGroupDescription", {
+      id: this.#id,
+      description,
+    });
+    this.#description = description;
+  }
+
+  get admins() {
+    return this.#admins;
+  }
+
+  get superAdmins() {
+    return this.#superAdmins;
+  }
+
+  async listAdmins() {
+    const admins = await this.#client.sendMessage("getGroupAdmins", {
+      id: this.#id,
+    });
+    this.#admins = admins;
+    return admins;
+  }
+
+  async listSuperAdmins() {
+    const superAdmins = await this.#client.sendMessage("getGroupSuperAdmins", {
+      id: this.#id,
+    });
+    this.#superAdmins = superAdmins;
+    return superAdmins;
+  }
+
+  async permissions() {
+    return this.#client.sendMessage("getGroupPermissions", {
+      id: this.#id,
+    });
+  }
+
+  async updatePermission(
+    permissionType: PermissionUpdateType,
+    policy: PermissionPolicy,
+    metadataField?: MetadataField,
+  ) {
+    return this.#client.sendMessage("updateGroupPermissionPolicy", {
+      id: this.#id,
+      permissionType,
+      policy,
+      metadataField,
+    });
+  }
+
+  async isAdmin(inboxId: string) {
+    const admins = await this.listAdmins();
+    return admins.includes(inboxId);
+  }
+
+  async isSuperAdmin(inboxId: string) {
+    const superAdmins = await this.listSuperAdmins();
+    return superAdmins.includes(inboxId);
+  }
+
+  async addMembers(accountAddresses: string[]) {
+    return this.#client.sendMessage("addGroupMembers", {
+      id: this.#id,
+      accountAddresses,
+    });
+  }
+
+  async addMembersByInboxId(inboxIds: string[]) {
+    return this.#client.sendMessage("addGroupMembersByInboxId", {
+      id: this.#id,
+      inboxIds,
+    });
+  }
+
+  async removeMembers(accountAddresses: string[]) {
+    return this.#client.sendMessage("removeGroupMembers", {
+      id: this.#id,
+      accountAddresses,
+    });
+  }
+
+  async removeMembersByInboxId(inboxIds: string[]) {
+    return this.#client.sendMessage("removeGroupMembersByInboxId", {
+      id: this.#id,
+      inboxIds,
+    });
+  }
+
+  async addAdmin(inboxId: string) {
+    return this.#client.sendMessage("addGroupAdmin", {
+      id: this.#id,
+      inboxId,
+    });
+  }
+
+  async removeAdmin(inboxId: string) {
+    return this.#client.sendMessage("removeGroupAdmin", {
+      id: this.#id,
+      inboxId,
+    });
+  }
+
+  async addSuperAdmin(inboxId: string) {
+    return this.#client.sendMessage("addGroupSuperAdmin", {
+      id: this.#id,
+      inboxId,
+    });
+  }
+
+  async removeSuperAdmin(inboxId: string) {
+    return this.#client.sendMessage("removeGroupSuperAdmin", {
+      id: this.#id,
+      inboxId,
+    });
+  }
+}

package/src/WorkerConversations.ts

@@ -1,10 +1,12 @@
 import {
   ConversationType,
+  type Consent,
   type ConsentState,
   type Conversation,
   type ConversationListItem,
   type Conversations,
   type Message,
+  type UserPreference,
 } from "@xmtp/wasm-bindings";
 import type { StreamCallback } from "@/AsyncStream";
 import {
@@ -172,4 +174,27 @@ export class WorkerConversations {
       conversationType,
     );
   }
+
+  streamConsent(callback?: StreamCallback<Consent[]>) {
+    const on_consent_update = (consent: Consent[]) => {
+      void callback?.(null, consent);
+    };
+    const on_error = (error: Error | null) => {
+      void callback?.(error, undefined);
+    };
+    return this.#conversations.streamConsent({ on_consent_update, on_error });
+  }
+
+  streamPreferences(callback?: StreamCallback<UserPreference[]>) {
+    const on_user_preference_update = (preferences: UserPreference[]) => {
+      void callback?.(null, preferences);
+    };
+    const on_error = (error: Error | null) => {
+      void callback?.(error, undefined);
+    };
+    return this.#conversations.streamPreferences({
+      on_user_preference_update,
+      on_error,
+    });
+  }
 }

package/src/index.ts

@@ -1,30 +1,41 @@
 export { Client } from "./Client";
 export { Conversations } from "./Conversations";
 export { Conversation } from "./Conversation";
+export { Dm } from "./Dm";
+export { Group } from "./Group";
 export type { MessageDeliveryStatus, MessageKind } from "./DecodedMessage";
 export { DecodedMessage } from "./DecodedMessage";
 export { Utils } from "./Utils";
 export { ApiUrls, HistorySyncUrls } from "./constants";
 export type * from "./types";
 export * from "./utils/conversions";
+export type { UserPreference } from "@xmtp/wasm-bindings";
 export {
+  Consent,
   ConsentEntityType,
   ConsentState,
+  ContentType,
+  ContentTypeId,
+  ConversationListItem,
   ConversationType,
+  CreateDMOptions,
   CreateGroupOptions,
   DeliveryStatus,
-  GroupMembershipState,
   EncodedContent,
   GroupMember,
+  GroupMembershipState,
+  GroupMessageKind,
   GroupMetadata,
   GroupPermissions,
-  GroupMessageKind,
   GroupPermissionsOptions,
+  HmacKey,
   InboxState,
   Installation,
   ListConversationsOptions,
   ListMessagesOptions,
+  LogOptions,
   Message,
+  MessageDisappearingSettings,
   MetadataField,
   PermissionLevel,
   PermissionPolicy,
@@ -32,12 +43,5 @@ export {
   PermissionUpdateType,
   SignatureRequestType,
   SortDirection,
-  Consent,
-  ContentTypeId,
-  HmacKey,
 } from "@xmtp/wasm-bindings";
-export {
-  isSmartContractSigner,
-  type Signer,
-  type SmartContractSigner,
-} from "./utils/signer";
+export type { Signer } from "./utils/signer";

package/src/types/clientEvents.ts

@@ -336,6 +336,22 @@ export type ClientEvents =
         conversationType?: ConversationType;
       };
     }
+  | {
+      action: "streamConsent";
+      id: string;
+      result: undefined;
+      data: {
+        streamId: string;
+      };
+    }
+  | {
+      action: "streamPreferences";
+      id: string;
+      result: undefined;
+      data: {
+        streamId: string;
+      };
+    }
   /**
    * Group actions
    */

package/src/types/clientStreamEvents.ts

@@ -1,9 +1,14 @@
+import type { UserPreference } from "@xmtp/wasm-bindings";
 import type {
   StreamEventsClientPostMessageData,
   StreamEventsErrorData,
   StreamEventsResult,
 } from "@/types";
-import type { SafeConversation, SafeMessage } from "@/utils/conversions";
+import type {
+  SafeConsent,
+  SafeConversation,
+  SafeMessage,
+} from "@/utils/conversions";
 
 export type ClientStreamEvents =
   | {
@@ -15,6 +20,16 @@ export type ClientStreamEvents =
       type: "group";
       streamId: string;
       result: SafeConversation | undefined;
+    }
+  | {
+      type: "consent";
+      streamId: string;
+      result: SafeConsent[] | undefined;
+    }
+  | {
+      type: "preferences";
+      streamId: string;
+      result: UserPreference[] | undefined;
     };
 
 export type ClientStreamEventsTypes = ClientStreamEvents["type"];

package/src/utils/conversions.ts

@@ -16,9 +16,8 @@ import {
   EncodedContent as WasmEncodedContent,
   type ConsentEntityType,
   type ConsentState,
-  type ConversationType,
+  type ContentType,
   type DeliveryStatus,
-  type GroupMembershipState,
   type GroupMessageKind,
   type HmacKey,
   type InboxState,
@@ -147,6 +146,7 @@ export const toSafeMessage = (message: Message): SafeMessage => ({
 });
 
 export type SafeListMessagesOptions = {
+  contentTypes?: ContentType[];
   deliveryStatus?: DeliveryStatus;
   direction?: SortDirection;
   limit?: bigint;
@@ -157,6 +157,7 @@ export type SafeListMessagesOptions = {
 export const toSafeListMessagesOptions = (
   options: ListMessagesOptions,
 ): SafeListMessagesOptions => ({
+  contentTypes: options.contentTypes,
   deliveryStatus: options.deliveryStatus,
   direction: options.direction,
   limit: options.limit,
@@ -173,29 +174,24 @@ export const fromSafeListMessagesOptions = (
     options.limit,
     options.deliveryStatus,
     options.direction,
+    options.contentTypes,
   );
 
 export type SafeListConversationsOptions = {
-  allowedStates?: GroupMembershipState[];
   consentStates?: ConsentState[];
-  conversationType?: ConversationType;
   createdAfterNs?: bigint;
   createdBeforeNs?: bigint;
   includeDuplicateDms?: boolean;
-  includeSyncGroups?: boolean;
   limit?: bigint;
 };
 
 export const toSafeListConversationsOptions = (
   options: ListConversationsOptions,
 ): SafeListConversationsOptions => ({
-  allowedStates: options.allowedStates,
   consentStates: options.consentStates,
-  conversationType: options.conversationType,
   createdAfterNs: options.createdAfterNs,
   createdBeforeNs: options.createdBeforeNs,
   includeDuplicateDms: options.includeDuplicateDms,
-  includeSyncGroups: options.includeSyncGroups,
   limit: options.limit,
 });
 
@@ -203,13 +199,10 @@ export const fromSafeListConversationsOptions = (
   options: SafeListConversationsOptions,
 ): ListConversationsOptions =>
   new ListConversationsOptions(
-    options.allowedStates,
     options.consentStates,
-    options.conversationType,
     options.createdAfterNs,
     options.createdBeforeNs,
     options.includeDuplicateDms ?? false,
-    options.includeSyncGroups ?? false,
     options.limit,
   );
 

package/src/utils/signer.ts

@@ -2,18 +2,17 @@ export type SignMessage = (message: string) => Promise<Uint8Array> | Uint8Array;
 export type GetAddress = () => Promise<string> | string;
 export type GetChainId = () => bigint;
 export type GetBlockNumber = () => bigint;
-export type WalletType = () => "EOA" | "SCW";
 
-export type Signer = {
-  getAddress: GetAddress;
-  signMessage: SignMessage;
-  walletType?: WalletType;
-  getBlockNumber?: GetBlockNumber;
-  getChainId?: GetChainId;
-};
-
-export type SmartContractSigner = Required<Signer>;
-
-export const isSmartContractSigner = (
-  signer: Signer,
-): signer is SmartContractSigner => signer.walletType?.() === "SCW";
+export type Signer =
+  | {
+      walletType: "EOA";
+      getAddress: GetAddress;
+      signMessage: SignMessage;
+    }
+  | {
+      walletType: "SCW";
+      getAddress: GetAddress;
+      signMessage: SignMessage;
+      getBlockNumber?: GetBlockNumber;
+      getChainId: GetChainId;
+    };