@xmtp/browser-sdk 0.0.1 → 0.0.3

package/src/WorkerConversation.ts

@@ -1,11 +1,12 @@
 import type {
-  WasmConsentState,
-  WasmEncodedContent,
-  WasmGroup,
-  WasmGroupMember,
+  ConsentState,
+  Conversation,
+  EncodedContent,
+  GroupMember,
 } from "@xmtp/wasm-bindings";
 import {
   fromSafeListMessagesOptions,
+  toSafeGroupMember,
   type SafeListMessagesOptions,
 } from "@/utils/conversions";
 import type { WorkerClient } from "@/WorkerClient";
@@ -14,9 +15,9 @@ export class WorkerConversation {
   // eslint-disable-next-line no-unused-private-class-members
   #client: WorkerClient;
 
-  #group: WasmGroup;
+  #group: Conversation;
 
-  constructor(client: WorkerClient, group: WasmGroup) {
+  constructor(client: WorkerClient, group: Conversation) {
     this.#client = client;
     this.#group = group;
   }
@@ -26,83 +27,84 @@ export class WorkerConversation {
   }
 
   get name() {
-    return this.#group.group_name();
+    return this.#group.groupName();
   }
 
   async updateName(name: string) {
-    return this.#group.update_group_name(name);
+    return this.#group.updateGroupName(name);
   }
 
   get imageUrl() {
-    return this.#group.group_image_url_square();
+    return this.#group.groupImageUrlSquare();
   }
 
   async updateImageUrl(imageUrl: string) {
-    return this.#group.update_group_image_url_square(imageUrl);
+    return this.#group.updateGroupImageUrlSquare(imageUrl);
   }
 
   get description() {
-    return this.#group.group_description();
+    return this.#group.groupDescription();
   }
 
   async updateDescription(description: string) {
-    return this.#group.update_group_description(description);
+    return this.#group.updateGroupDescription(description);
   }
 
   get pinnedFrameUrl() {
-    return this.#group.group_pinned_frame_url();
+    return this.#group.groupPinnedFrameUrl();
   }
 
   async updatePinnedFrameUrl(pinnedFrameUrl: string) {
-    return this.#group.update_group_pinned_frame_url(pinnedFrameUrl);
+    return this.#group.updateGroupPinnedFrameUrl(pinnedFrameUrl);
   }
 
   get isActive() {
-    return this.#group.is_active();
+    return this.#group.isActive();
   }
 
   get addedByInboxId() {
-    return this.#group.added_by_inbox_id();
+    return this.#group.addedByInboxId();
   }
 
   get createdAtNs() {
-    return this.#group.created_at_ns();
+    return this.#group.createdAtNs();
   }
 
   get metadata() {
-    const metadata = this.#group.group_metadata();
+    const metadata = this.#group.groupMetadata();
     return {
-      creatorInboxId: metadata.creator_inbox_id(),
-      conversationType: metadata.conversation_type(),
+      creatorInboxId: metadata.creatorInboxId(),
+      conversationType: metadata.conversationType(),
     };
   }
 
   async members() {
-    return this.#group.list_members() as Promise<WasmGroupMember[]>;
+    const members = (await this.#group.listMembers()) as GroupMember[];
+    return members.map((member) => toSafeGroupMember(member));
   }
 
   get admins() {
-    return this.#group.admin_list();
+    return this.#group.adminList();
   }
 
   get superAdmins() {
-    return this.#group.super_admin_list();
+    return this.#group.superAdminList();
   }
 
   get permissions() {
-    const permissions = this.#group.group_permissions();
+    const permissions = this.#group.groupPermissions();
     return {
-      policyType: permissions.policy_type(),
-      policySet: permissions.policy_set(),
+      policyType: permissions.policyType(),
+      policySet: permissions.policySet(),
     };
   }
 
   isAdmin(inboxId: string) {
-    return this.#group.is_admin(inboxId);
+    return this.#group.isAdmin(inboxId);
   }
 
   isSuperAdmin(inboxId: string) {
-    return this.#group.is_super_admin(inboxId);
+    return this.#group.isSuperAdmin(inboxId);
   }
 
   async sync() {
@@ -110,60 +112,64 @@ export class WorkerConversation {
   }
 
   async addMembers(accountAddresses: string[]) {
-    return this.#group.add_members(accountAddresses);
+    return this.#group.addMembers(accountAddresses);
   }
 
   async addMembersByInboxId(inboxIds: string[]) {
-    return this.#group.add_members_by_inbox_id(inboxIds);
+    return this.#group.addMembersByInboxId(inboxIds);
   }
 
   async removeMembers(accountAddresses: string[]) {
-    return this.#group.remove_members(accountAddresses);
+    return this.#group.removeMembers(accountAddresses);
   }
 
   async removeMembersByInboxId(inboxIds: string[]) {
-    return this.#group.remove_members_by_inbox_id(inboxIds);
+    return this.#group.removeMembersByInboxId(inboxIds);
   }
 
   async addAdmin(inboxId: string) {
-    return this.#group.add_admin(inboxId);
+    return this.#group.addAdmin(inboxId);
   }
 
   async removeAdmin(inboxId: string) {
-    return this.#group.remove_admin(inboxId);
+    return this.#group.removeAdmin(inboxId);
   }
 
   async addSuperAdmin(inboxId: string) {
-    return this.#group.add_super_admin(inboxId);
+    return this.#group.addSuperAdmin(inboxId);
   }
 
   async removeSuperAdmin(inboxId: string) {
-    return this.#group.remove_super_admin(inboxId);
+    return this.#group.removeSuperAdmin(inboxId);
   }
 
   async publishMessages() {
-    return this.#group.publish_messages();
+    return this.#group.publishMessages();
   }
 
-  sendOptimistic(encodedContent: WasmEncodedContent) {
-    return this.#group.send_optimistic(encodedContent);
+  sendOptimistic(encodedContent: EncodedContent) {
+    return this.#group.sendOptimistic(encodedContent);
   }
 
-  async send(encodedContent: WasmEncodedContent) {
+  async send(encodedContent: EncodedContent) {
     return this.#group.send(encodedContent);
   }
 
   messages(options?: SafeListMessagesOptions) {
-    return this.#group.find_messages(
+    return this.#group.findMessages(
       options ? fromSafeListMessagesOptions(options) : undefined,
     );
   }
 
   get consentState() {
-    return this.#group.consent_state();
+    return this.#group.consentState();
   }
 
-  updateConsentState(state: WasmConsentState) {
-    this.#group.update_consent_state(state);
+  updateConsentState(state: ConsentState) {
+    this.#group.updateConsentState(state);
+  }
+
+  dmPeerInboxId() {
+    return this.#group.dmPeerInboxId();
   }
 }

package/src/WorkerConversations.ts

@@ -1,4 +1,4 @@
-import type { WasmConversations, WasmGroup } from "@xmtp/wasm-bindings";
+import type { Conversation, Conversations } from "@xmtp/wasm-bindings";
 import {
   fromSafeCreateGroupOptions,
   fromSafeListConversationsOptions,
@@ -12,9 +12,9 @@ import { WorkerConversation } from "@/WorkerConversation";
 export class WorkerConversations {
   #client: WorkerClient;
 
-  #conversations: WasmConversations;
+  #conversations: Conversations;
 
-  constructor(client: WorkerClient, conversations: WasmConversations) {
+  constructor(client: WorkerClient, conversations: Conversations) {
     this.#client = client;
     this.#conversations = conversations;
   }
@@ -25,7 +25,7 @@ export class WorkerConversations {
 
   getConversationById(id: string) {
     try {
-      const group = this.#conversations.find_group_by_id(id);
+      const group = this.#conversations.findGroupById(id);
       // findGroupById will throw if group is not found
       return new WorkerConversation(this.#client, group);
     } catch {
@@ -36,25 +36,57 @@ export class WorkerConversations {
   getMessageById(id: string) {
     try {
       // findMessageById will throw if message is not found
-      const message = this.#conversations.find_message_by_id(id);
+      const message = this.#conversations.findMessageById(id);
       return toSafeMessage(message);
     } catch {
       return undefined;
     }
   }
 
+  getDmByInboxId(inboxId: string) {
+    try {
+      const group = this.#conversations.findDmByTargetInboxId(inboxId);
+      return new WorkerConversation(this.#client, group);
+    } catch {
+      return undefined;
+    }
+  }
+
   async list(options?: SafeListConversationsOptions) {
     const groups = (await this.#conversations.list(
       options ? fromSafeListConversationsOptions(options) : undefined,
-    )) as WasmGroup[];
+    )) as Conversation[];
+    return groups.map((group) => new WorkerConversation(this.#client, group));
+  }
+
+  async listGroups(
+    options?: Omit<SafeListConversationsOptions, "conversation_type">,
+  ) {
+    const groups = (await this.#conversations.listGroups(
+      options ? fromSafeListConversationsOptions(options) : undefined,
+    )) as Conversation[];
+    return groups.map((group) => new WorkerConversation(this.#client, group));
+  }
+
+  async listDms(
+    options?: Omit<SafeListConversationsOptions, "conversation_type">,
+  ) {
+    const groups = (await this.#conversations.listDms(
+      options ? fromSafeListConversationsOptions(options) : undefined,
+    )) as Conversation[];
     return groups.map((group) => new WorkerConversation(this.#client, group));
   }
 
   async newGroup(accountAddresses: string[], options?: SafeCreateGroupOptions) {
-    const group = await this.#conversations.create_group(
+    const group = await this.#conversations.createGroup(
       accountAddresses,
       options ? fromSafeCreateGroupOptions(options) : undefined,
     );
     return new WorkerConversation(this.#client, group);
   }
+
+  async newDm(accountAddress: string) {
+    const group = await this.#conversations.createDm(accountAddress);
+    return new WorkerConversation(this.#client, group);
+  }
 }

package/src/index.ts

@@ -1,9 +1,36 @@
 export { Client } from "./Client";
 export { Conversations } from "./Conversations";
 export { Conversation } from "./Conversation";
-export * from "./DecodedMessage";
+export type { MessageDeliveryStatus, MessageKind } from "./DecodedMessage";
+export { DecodedMessage } from "./DecodedMessage";
 export { Utils } from "./Utils";
 export { ApiUrls } from "./constants";
 export type * from "./types";
 export * from "./utils/conversions";
-export type * from "@xmtp/wasm-bindings";
+export {
+  ConsentEntityType,
+  ConsentState,
+  ConversationType,
+  CreateGroupOptions,
+  DeliveryStatus,
+  GroupMembershipState,
+  EncodedContent,
+  GroupMember,
+  GroupMetadata,
+  GroupPermissions,
+  GroupMessageKind,
+  GroupPermissionsOptions,
+  InboxState,
+  Installation,
+  ListConversationsOptions,
+  ListMessagesOptions,
+  Message,
+  PermissionLevel,
+  PermissionPolicy,
+  PermissionPolicySet,
+  PermissionUpdateType,
+  SignatureRequestType,
+  SortDirection,
+  Consent,
+  ContentTypeId,
+} from "@xmtp/wasm-bindings";

package/src/types/clientEvents.ts

@@ -1,7 +1,7 @@
 import type {
-  WasmConsentEntityType,
-  WasmConsentState,
-  WasmSignatureRequestType,
+  ConsentEntityType,
+  ConsentState,
+  SignatureRequestType,
 } from "@xmtp/wasm-bindings";
 import type {
   ClientOptions,
@@ -38,6 +38,7 @@ export type ClientEvents =
       };
       data: {
         address: string;
+        encryptionKey: Uint8Array;
         options?: ClientOptions;
       };
     }
@@ -74,12 +75,23 @@ export type ClientEvents =
       id: string;
       result: undefined;
       data: {
-        type: WasmSignatureRequestType;
+        type: SignatureRequestType;
         bytes: Uint8Array;
       };
     }
   | {
-      action: "applySignaturesRequests";
+      action: "addScwSignature";
+      id: string;
+      result: undefined;
+      data: {
+        type: SignatureRequestType;
+        bytes: Uint8Array;
+        chainId: bigint;
+        blockNumber?: bigint;
+      };
+    }
+  | {
+      action: "applySignatures";
       id: string;
       result: undefined;
       data: undefined;
@@ -131,9 +143,9 @@ export type ClientEvents =
   | {
       action: "getConsentState";
       id: string;
-      result: WasmConsentState;
+      result: ConsentState;
       data: {
-        entityType: WasmConsentEntityType;
+        entityType: ConsentEntityType;
         entity: string;
       };
     }
@@ -164,6 +176,14 @@ export type ClientEvents =
         id: string;
       };
     }
+  | {
+      action: "getDmByInboxId";
+      id: string;
+      result: SafeConversation | undefined;
+      data: {
+        inboxId: string;
+      };
+    }
   | {
       action: "getConversations";
       id: string;
@@ -172,6 +192,22 @@ export type ClientEvents =
         options?: SafeListConversationsOptions;
       };
     }
+  | {
+      action: "getGroups";
+      id: string;
+      result: SafeConversation[];
+      data: {
+        options?: Omit<SafeListConversationsOptions, "conversation_type">;
+      };
+    }
+  | {
+      action: "getDms";
+      id: string;
+      result: SafeConversation[];
+      data: {
+        options?: Omit<SafeListConversationsOptions, "conversation_type">;
+      };
+    }
   | {
       action: "newGroup";
       id: string;
@@ -181,6 +217,14 @@ export type ClientEvents =
         options?: SafeCreateGroupOptions;
       };
     }
+  | {
+      action: "newDm";
+      id: string;
+      result: SafeConversation;
+      data: {
+        accountAddress: string;
+      };
+    }
   | {
       action: "syncConversations";
       id: string;
@@ -386,7 +430,7 @@ export type ClientEvents =
   | {
       action: "getGroupConsentState";
       id: string;
-      result: WasmConsentState;
+      result: ConsentState;
       data: {
         id: string;
       };
@@ -397,7 +441,15 @@ export type ClientEvents =
       result: undefined;
       data: {
         id: string;
-        state: WasmConsentState;
+        state: ConsentState;
+      };
+    }
+  | {
+      action: "getDmPeerInboxId";
+      id: string;
+      result: string;
+      data: {
+        id: string;
       };
     };
 

package/src/types/options.ts

@@ -18,16 +18,6 @@ export type NetworkOptions = {
   apiUrl?: string;
 };
 
-/**
- * Encryption options
- */
-export type EncryptionOptions = {
-  /**
-   * Encryption key to use for the local DB
-   */
-  encryptionKey?: Uint8Array;
-};
-
 /**
  * Storage options
  */
@@ -47,13 +37,20 @@ export type ContentOptions = {
 
 export type OtherOptions = {
   /**
-   * Enable logging of events between the client and worker
+   * Enable structured JSON logging
+   */
+  structuredLogging?: boolean;
+  /**
+   * Enable performance metrics
+   */
+  performanceLogging?: boolean;
+  /**
+   * Logging level
    */
-  enableLogging?: boolean;
+  loggingLevel?: "off" | "error" | "warn" | "info" | "debug" | "trace";
 };
 
 export type ClientOptions = NetworkOptions &
-  EncryptionOptions &
   StorageOptions &
   ContentOptions &
   OtherOptions;