@xmtp/browser-sdk 0.0.1 → 0.0.3

package/src/utils/conversions.ts

@@ -3,23 +3,26 @@ import {
   type EncodedContent,
 } from "@xmtp/content-type-primitives";
 import {
-  WasmConsent,
-  WasmContentTypeId,
-  WasmCreateGroupOptions,
-  WasmEncodedContent,
-  WasmGroupMember,
-  WasmListConversationsOptions,
-  WasmListMessagesOptions,
-  type WasmConsentEntityType,
-  type WasmConsentState,
-  type WasmDeliveryStatus,
-  type WasmGroupMessageKind,
-  type WasmGroupPermissionsOptions,
-  type WasmInboxState,
-  type WasmInstallation,
-  type WasmMessage,
-  type WasmPermissionLevel,
-  type WasmPermissionPolicy,
+  Consent,
+  CreateGroupOptions,
+  GroupMember,
+  ListConversationsOptions,
+  ListMessagesOptions,
+  ContentTypeId as WasmContentTypeId,
+  EncodedContent as WasmEncodedContent,
+  type ConsentEntityType,
+  type ConsentState,
+  type ConversationType,
+  type DeliveryStatus,
+  type GroupMembershipState,
+  type GroupMessageKind,
+  type GroupPermissionsOptions,
+  type InboxState,
+  type Installation,
+  type Message,
+  type PermissionLevel,
+  type PermissionPolicy,
+  type SortDirection,
 } from "@xmtp/wasm-bindings";
 import type { WorkerConversation } from "@/WorkerConversation";
 
@@ -27,10 +30,10 @@ export const toContentTypeId = (
   contentTypeId: WasmContentTypeId,
 ): ContentTypeId =>
   new ContentTypeId({
-    authorityId: contentTypeId.authority_id,
-    typeId: contentTypeId.type_id,
-    versionMajor: contentTypeId.version_major,
-    versionMinor: contentTypeId.version_minor,
+    authorityId: contentTypeId.authorityId,
+    typeId: contentTypeId.typeId,
+    versionMajor: contentTypeId.versionMajor,
+    versionMinor: contentTypeId.versionMinor,
   });
 
 export const fromContentTypeId = (
@@ -122,74 +125,83 @@ export const fromSafeEncodedContent = (
 export type SafeMessage = {
   content: SafeEncodedContent;
   convoId: string;
-  deliveryStatus: WasmDeliveryStatus;
+  deliveryStatus: DeliveryStatus;
   id: string;
-  kind: WasmGroupMessageKind;
+  kind: GroupMessageKind;
   senderInboxId: string;
   sentAtNs: bigint;
 };
 
-export const toSafeMessage = (message: WasmMessage): SafeMessage => ({
+export const toSafeMessage = (message: Message): SafeMessage => ({
   content: toSafeEncodedContent(toEncodedContent(message.content)),
-  convoId: message.convo_id,
-  deliveryStatus: message.delivery_status,
+  convoId: message.convoId,
+  deliveryStatus: message.deliveryStatus,
   id: message.id,
   kind: message.kind,
-  senderInboxId: message.sender_inbox_id,
-  sentAtNs: message.sent_at_ns,
+  senderInboxId: message.senderInboxId,
+  sentAtNs: message.sentAtNs,
 });
 
 export type SafeListMessagesOptions = {
-  delivery_status?: WasmDeliveryStatus;
+  deliveryStatus?: DeliveryStatus;
+  direction?: SortDirection;
   limit?: bigint;
-  sent_after_ns?: bigint;
-  sent_before_ns?: bigint;
+  sentAfterNs?: bigint;
+  sentBeforeNs?: bigint;
 };
 
 export const toSafeListMessagesOptions = (
-  options: WasmListMessagesOptions,
+  options: ListMessagesOptions,
 ): SafeListMessagesOptions => ({
-  delivery_status: options.delivery_status,
+  deliveryStatus: options.deliveryStatus,
+  direction: options.direction,
   limit: options.limit,
-  sent_after_ns: options.sent_after_ns,
-  sent_before_ns: options.sent_before_ns,
+  sentAfterNs: options.sentAfterNs,
+  sentBeforeNs: options.sentBeforeNs,
 });
 
 export const fromSafeListMessagesOptions = (
   options: SafeListMessagesOptions,
-): WasmListMessagesOptions =>
-  new WasmListMessagesOptions(
-    options.sent_before_ns,
-    options.sent_after_ns,
+): ListMessagesOptions =>
+  new ListMessagesOptions(
+    options.sentBeforeNs,
+    options.sentAfterNs,
     options.limit,
-    options.delivery_status,
+    options.deliveryStatus,
+    options.direction,
   );
 
 export type SafeListConversationsOptions = {
-  created_after_ns?: bigint;
-  created_before_ns?: bigint;
+  allowedStates?: GroupMembershipState[];
+  conversationType?: ConversationType;
+  createdAfterNs?: bigint;
+  createdBeforeNs?: bigint;
   limit?: bigint;
 };
 
 export const toSafeListConversationsOptions = (
-  options: WasmListConversationsOptions,
+  options: ListConversationsOptions,
 ): SafeListConversationsOptions => ({
-  created_after_ns: options.created_after_ns,
-  created_before_ns: options.created_before_ns,
+  allowedStates: options.allowedStates,
+  conversationType: options.conversationType,
+  createdAfterNs: options.createdAfterNs,
+  createdBeforeNs: options.createdBeforeNs,
   limit: options.limit,
 });
 
 export const fromSafeListConversationsOptions = (
   options: SafeListConversationsOptions,
-): WasmListConversationsOptions =>
-  new WasmListConversationsOptions(
-    options.created_after_ns,
-    options.created_before_ns,
+): ListConversationsOptions =>
+  new ListConversationsOptions(
+    options.allowedStates,
+    options.conversationType,
+    options.createdAfterNs,
+    options.createdBeforeNs,
     options.limit,
   );
 
 export type SafeCreateGroupOptions = {
-  permissions?: WasmGroupPermissionsOptions;
+  permissions?: GroupPermissionsOptions;
   name?: string;
   imageUrlSquare?: string;
   description?: string;
@@ -197,19 +209,19 @@ export type SafeCreateGroupOptions = {
 };
 
 export const toSafeCreateGroupOptions = (
-  options: WasmCreateGroupOptions,
+  options: CreateGroupOptions,
 ): SafeCreateGroupOptions => ({
   permissions: options.permissions,
-  name: options.group_name,
-  imageUrlSquare: options.group_image_url_square,
-  description: options.group_description,
-  pinnedFrameUrl: options.group_pinned_frame_url,
+  name: options.groupName,
+  imageUrlSquare: options.groupImageUrlSquare,
+  description: options.groupDescription,
+  pinnedFrameUrl: options.groupPinnedFrameUrl,
 });
 
 export const fromSafeCreateGroupOptions = (
   options: SafeCreateGroupOptions,
-): WasmCreateGroupOptions =>
-  new WasmCreateGroupOptions(
+): CreateGroupOptions =>
+  new CreateGroupOptions(
     options.permissions,
     options.name,
     options.imageUrlSquare,
@@ -224,16 +236,16 @@ export type SafeConversation = {
   description: string;
   pinnedFrameUrl: string;
   permissions: {
-    policyType: WasmGroupPermissionsOptions;
+    policyType: GroupPermissionsOptions;
     policySet: {
-      addAdminPolicy: WasmPermissionPolicy;
-      addMemberPolicy: WasmPermissionPolicy;
-      removeAdminPolicy: WasmPermissionPolicy;
-      removeMemberPolicy: WasmPermissionPolicy;
-      updateGroupDescriptionPolicy: WasmPermissionPolicy;
-      updateGroupImageUrlSquarePolicy: WasmPermissionPolicy;
-      updateGroupNamePolicy: WasmPermissionPolicy;
-      updateGroupPinnedFrameUrlPolicy: WasmPermissionPolicy;
+      addAdminPolicy: PermissionPolicy;
+      addMemberPolicy: PermissionPolicy;
+      removeAdminPolicy: PermissionPolicy;
+      removeMemberPolicy: PermissionPolicy;
+      updateGroupDescriptionPolicy: PermissionPolicy;
+      updateGroupImageUrlSquarePolicy: PermissionPolicy;
+      updateGroupNamePolicy: PermissionPolicy;
+      updateGroupPinnedFrameUrlPolicy: PermissionPolicy;
     };
   };
   isActive: boolean;
@@ -258,19 +270,18 @@ export const toSafeConversation = (
   permissions: {
     policyType: conversation.permissions.policyType,
     policySet: {
-      addAdminPolicy: conversation.permissions.policySet.add_admin_policy,
-      addMemberPolicy: conversation.permissions.policySet.add_member_policy,
-      removeAdminPolicy: conversation.permissions.policySet.remove_admin_policy,
-      removeMemberPolicy:
-        conversation.permissions.policySet.remove_member_policy,
+      addAdminPolicy: conversation.permissions.policySet.addAdminPolicy,
+      addMemberPolicy: conversation.permissions.policySet.addMemberPolicy,
+      removeAdminPolicy: conversation.permissions.policySet.removeAdminPolicy,
+      removeMemberPolicy: conversation.permissions.policySet.removeMemberPolicy,
       updateGroupDescriptionPolicy:
-        conversation.permissions.policySet.update_group_description_policy,
+        conversation.permissions.policySet.updateGroupDescriptionPolicy,
       updateGroupImageUrlSquarePolicy:
-        conversation.permissions.policySet.update_group_image_url_square_policy,
+        conversation.permissions.policySet.updateGroupImageUrlSquarePolicy,
       updateGroupNamePolicy:
-        conversation.permissions.policySet.update_group_name_policy,
+        conversation.permissions.policySet.updateGroupNamePolicy,
       updateGroupPinnedFrameUrlPolicy:
-        conversation.permissions.policySet.update_group_pinned_frame_url_policy,
+        conversation.permissions.policySet.updateGroupPinnedFrameUrlPolicy,
     },
   },
   isActive: conversation.isActive,
@@ -287,10 +298,10 @@ export type SafeInstallation = {
 };
 
 export const toSafeInstallation = (
-  installation: WasmInstallation,
+  installation: Installation,
 ): SafeInstallation => ({
   id: installation.id,
-  clientTimestampNs: installation.client_timestamp_ns,
+  clientTimestampNs: installation.clientTimestampNs,
 });
 
 export type SafeInboxState = {
@@ -300,50 +311,46 @@ export type SafeInboxState = {
   recoveryAddress: string;
 };
 
-export const toSafeInboxState = (
-  inboxState: WasmInboxState,
-): SafeInboxState => ({
-  accountAddresses: inboxState.account_addresses,
-  inboxId: inboxState.inbox_id,
+export const toSafeInboxState = (inboxState: InboxState): SafeInboxState => ({
+  accountAddresses: inboxState.accountAddresses,
+  inboxId: inboxState.inboxId,
   installations: inboxState.installations.map(toSafeInstallation),
-  recoveryAddress: inboxState.recovery_address,
+  recoveryAddress: inboxState.recoveryAddress,
 });
 
 export type SafeConsent = {
   entity: string;
-  entityType: WasmConsentEntityType;
-  state: WasmConsentState;
+  entityType: ConsentEntityType;
+  state: ConsentState;
 };
 
-export const toSafeConsent = (consent: WasmConsent): SafeConsent => ({
+export const toSafeConsent = (consent: Consent): SafeConsent => ({
   entity: consent.entity,
-  entityType: consent.entity_type,
+  entityType: consent.entityType,
   state: consent.state,
 });
 
-export const fromSafeConsent = (consent: SafeConsent): WasmConsent =>
-  new WasmConsent(consent.entityType, consent.state, consent.entity);
+export const fromSafeConsent = (consent: SafeConsent): Consent =>
+  new Consent(consent.entityType, consent.state, consent.entity);
 
 export type SafeGroupMember = {
   accountAddresses: string[];
-  consentState: WasmConsentState;
+  consentState: ConsentState;
   inboxId: string;
   installationIds: string[];
-  permissionLevel: WasmPermissionLevel;
+  permissionLevel: PermissionLevel;
 };
 
-export const toSafeGroupMember = (
-  member: WasmGroupMember,
-): SafeGroupMember => ({
-  accountAddresses: member.account_addresses,
-  consentState: member.consent_state,
-  inboxId: member.inbox_id,
-  installationIds: member.installation_ids,
-  permissionLevel: member.permission_level,
+export const toSafeGroupMember = (member: GroupMember): SafeGroupMember => ({
+  accountAddresses: member.accountAddresses,
+  consentState: member.consentState,
+  inboxId: member.inboxId,
+  installationIds: member.installationIds,
+  permissionLevel: member.permissionLevel,
 });
 
-export const fromSafeGroupMember = (member: SafeGroupMember): WasmGroupMember =>
-  new WasmGroupMember(
+export const fromSafeGroupMember = (member: SafeGroupMember): GroupMember =>
+  new GroupMember(
     member.inboxId,
     member.accountAddresses,
     member.installationIds,

package/src/utils/createClient.ts

@@ -2,29 +2,50 @@ import init, {
   createClient as createWasmClient,
   generateInboxId,
   getInboxIdForAddress,
+  LogOptions,
 } from "@xmtp/wasm-bindings";
 import { ApiUrls } from "@/constants";
 import type { ClientOptions } from "@/types";
 
 export const createClient = async (
   accountAddress: string,
+  encryptionKey: Uint8Array,
   options?: Omit<ClientOptions, "codecs">,
 ) => {
   // initialize WASM module
   await init();
 
   const host = options?.apiUrl ?? ApiUrls[options?.env ?? "dev"];
-  const dbPath = `xmtp-${options?.env ?? "dev"}-${accountAddress}.db3`;
+  // TODO: add db path validation
+  //       - must end with .db3
+  //       - must not contain invalid characters
+  //       - must not start with a dot
+  const dbPath =
+    options?.dbPath ?? `xmtp-${options?.env ?? "dev"}-${accountAddress}.db3`;
 
   const inboxId =
     (await getInboxIdForAddress(host, accountAddress)) ||
     generateInboxId(accountAddress);
 
+  const isLogging =
+    options &&
+    (options.loggingLevel !== undefined ||
+      options.structuredLogging ||
+      options.performanceLogging);
+
   return createWasmClient(
     host,
     inboxId,
     accountAddress,
     dbPath,
-    options?.encryptionKey,
+    encryptionKey,
+    undefined,
+    isLogging
+      ? new LogOptions(
+          options.structuredLogging ?? false,
+          options.performanceLogging ?? false,
+          options.loggingLevel,
+        )
+      : undefined,
   );
 };

package/src/workers/client.ts

@@ -8,7 +8,6 @@ import {
   fromEncodedContent,
   fromSafeEncodedContent,
   toSafeConversation,
-  toSafeGroupMember,
   toSafeInboxState,
   toSafeMessage,
 } from "@/utils/conversions";
@@ -57,8 +56,14 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
        * Client actions
        */
       case "init":
-        client = await WorkerClient.create(data.address, data.options);
-        enableLogging = data.options?.enableLogging ?? false;
+        client = await WorkerClient.create(
+          data.address,
+          data.encryptionKey,
+          data.options,
+        );
+        enableLogging =
+          data.options?.loggingLevel !== undefined &&
+          data.options.loggingLevel !== "off";
         postMessage({
           id,
           action,
@@ -99,6 +104,15 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
         });
         break;
       }
+      case "getRevokeInstallationsSignatureText": {
+        const result = await client.getRevokeInstallationsSignatureText();
+        postMessage({
+          id,
+          action,
+          result,
+        });
+        break;
+      }
       case "addSignature":
         await client.addSignature(data.type, data.bytes);
         postMessage({
@@ -107,8 +121,21 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
           result: undefined,
         });
         break;
-      case "applySignaturesRequests":
-        await client.applySignaturesRequests();
+      case "addScwSignature":
+        await client.addScwSignature(
+          data.type,
+          data.bytes,
+          data.chainId,
+          data.blockNumber,
+        );
+        postMessage({
+          id,
+          action,
+          result: undefined,
+        });
+        break;
+      case "applySignatures":
+        await client.applySignatures();
         postMessage({
           id,
           action,
@@ -203,6 +230,30 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
         });
         break;
       }
+      case "getGroups": {
+        const conversations = await client.conversations.listGroups(
+          data.options,
+        );
+        postMessage({
+          id,
+          action,
+          result: conversations.map((conversation) =>
+            toSafeConversation(conversation),
+          ),
+        });
+        break;
+      }
+      case "getDms": {
+        const conversations = await client.conversations.listDms(data.options);
+        postMessage({
+          id,
+          action,
+          result: conversations.map((conversation) =>
+            toSafeConversation(conversation),
+          ),
+        });
+        break;
+      }
       case "newGroup": {
         const conversation = await client.conversations.newGroup(
           data.accountAddresses,
@@ -215,6 +266,17 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
         });
         break;
       }
+      case "newDm": {
+        const conversation = await client.conversations.newDm(
+          data.accountAddress,
+        );
+        postMessage({
+          id,
+          action,
+          result: toSafeConversation(conversation),
+        });
+        break;
+      }
       case "syncConversations": {
         await client.conversations.sync();
         postMessage({
@@ -242,6 +304,15 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
         });
         break;
       }
+      case "getDmByInboxId": {
+        const conversation = client.conversations.getDmByInboxId(data.inboxId);
+        postMessage({
+          id,
+          action,
+          result: conversation ? toSafeConversation(conversation) : undefined,
+        });
+        break;
+      }
       /**
        * Group actions
        */
@@ -414,11 +485,11 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
       case "getGroupMembers": {
         const group = client.conversations.getConversationById(data.id);
         if (group) {
-          const members = await group.members();
+          const result = await group.members();
           postMessage({
             id,
             action,
-            result: members.map((member) => toSafeGroupMember(member)),
+            result,
           });
         } else {
           postMessageError({
@@ -678,6 +749,24 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
         }
         break;
       }
+      case "getDmPeerInboxId": {
+        const group = client.conversations.getConversationById(data.id);
+        if (group) {
+          const result = group.dmPeerInboxId();
+          postMessage({
+            id,
+            action,
+            result,
+          });
+        } else {
+          postMessageError({
+            id,
+            action,
+            error: "Group not found",
+          });
+        }
+        break;
+      }
     }
   } catch (e) {
     postMessageError({