@xmtp/browser-sdk 1.1.3 → 2.0.0

package/src/utils/createClient.ts

@@ -10,7 +10,6 @@ import type { ClientOptions } from "@/types";
 
 export const createClient = async (
   identifier: Identifier,
-  encryptionKey: Uint8Array,
   options?: Omit<ClientOptions, "codecs">,
 ) => {
   const host = options?.apiUrl || ApiUrls[options?.env || "dev"];
@@ -18,7 +17,9 @@ export const createClient = async (
     (await getInboxIdForIdentifier(host, identifier)) ||
     generateInboxId(identifier);
   const dbPath =
-    options?.dbPath || `xmtp-${options?.env || "dev"}-${inboxId}.db3`;
+    options?.dbPath === undefined
+      ? `xmtp-${options?.env || "dev"}-${inboxId}.db3`
+      : options.dbPath;
   const isLogging =
     options &&
     (options.loggingLevel !== undefined ||
@@ -33,7 +34,7 @@ export const createClient = async (
     inboxId,
     identifier,
     dbPath,
-    encryptionKey,
+    options?.dbEncryptionKey,
     historySyncUrl,
     isLogging
       ? new LogOptions(

package/src/utils/errors.ts

@@ -0,0 +1,86 @@
+import type { ContentTypeId } from "@xmtp/content-type-primitives";
+import { SignatureRequestType } from "@xmtp/wasm-bindings";
+
+export class ClientNotInitializedError extends Error {
+  constructor() {
+    super("Client not initialized");
+  }
+}
+
+export class SignerUnavailableError extends Error {
+  constructor() {
+    super(
+      "Signer unavailable, use Client.create to create a client with a signer",
+    );
+  }
+}
+
+export class CodecNotFoundError extends Error {
+  constructor(contentType: ContentTypeId) {
+    super(`Codec not found for "${contentType.toString()}" content type`);
+  }
+}
+
+export class InboxReassignError extends Error {
+  constructor() {
+    super(
+      "Unable to create add account signature text, `allowInboxReassign` must be true",
+    );
+  }
+}
+
+export class AccountAlreadyAssociatedError extends Error {
+  constructor(inboxId: string) {
+    super(`Account already associated with inbox ${inboxId}`);
+  }
+}
+
+export class GenerateSignatureError extends Error {
+  constructor(signatureType: SignatureRequestType) {
+    let type = "";
+
+    switch (signatureType) {
+      case SignatureRequestType.AddWallet:
+        type = "add account";
+        break;
+      case SignatureRequestType.CreateInbox:
+        type = "create inbox";
+        break;
+      case SignatureRequestType.RevokeWallet:
+        type = "remove account";
+        break;
+      case SignatureRequestType.RevokeInstallations:
+        type = "revoke installations";
+        break;
+      case SignatureRequestType.ChangeRecoveryIdentifier:
+        type = "change recovery identifier";
+        break;
+    }
+
+    super(`Failed to generate ${type} signature text`);
+  }
+}
+
+export class GroupNotFoundError extends Error {
+  constructor(groupId: string) {
+    super(`Group "${groupId}" not found`);
+  }
+}
+
+export class StreamNotFoundError extends Error {
+  constructor(streamId: string) {
+    super(`Stream "${streamId}" not found`);
+  }
+}
+
+export class InvalidGroupMembershipChangeError extends Error {
+  constructor(messageId: string) {
+    super(`Invalid group membership change for message ${messageId}`);
+  }
+}
+
+export class MissingContentTypeError extends Error {
+  constructor() {
+    super("Content type is required when sending content other than text");
+  }
+}

package/src/workers/client.ts

@@ -23,9 +23,15 @@ import {
   toSafeConversation,
   toSafeHmacKey,
   toSafeInboxState,
+  toSafeKeyPackageStatus,
   toSafeMessage,
   toSafeMessageDisappearingSettings,
 } from "@/utils/conversions";
+import {
+  ClientNotInitializedError,
+  GroupNotFoundError,
+  StreamNotFoundError,
+} from "@/utils/errors";
 import { WorkerClient } from "@/WorkerClient";
 import { WorkerConversation } from "@/WorkerConversation";
 
@@ -79,11 +85,7 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
   try {
     // init is a special action that initializes the client
     if (action === "init" && !maybeClient) {
-      maybeClient = await WorkerClient.create(
-        data.identifier,
-        data.encryptionKey,
-        data.options,
-      );
+      maybeClient = await WorkerClient.create(data.identifier, data.options);
       enableLogging =
         data.options?.loggingLevel !== undefined &&
         data.options.loggingLevel !== "off";
@@ -101,7 +103,7 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
 
     // a client is required for all other actions
     if (!maybeClient) {
-      throw new Error("Client not initialized");
+      throw new ClientNotInitializedError();
     }
 
     // let typescript know that a client will be available for the rest
@@ -112,7 +114,7 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
     const getGroup = (groupId: string) => {
       const group = client.conversations.getConversationById(groupId);
       if (!group) {
-        throw new Error(`Group "${groupId}" not found`);
+        throw new GroupNotFoundError(groupId);
       }
       return group;
     };
@@ -128,7 +130,7 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
           streamClosers.delete(data.streamId);
           postMessage({ id, action, result: undefined });
         } else {
-          throw new Error(`Stream "${data.streamId}" not found`);
+          throw new StreamNotFoundError(data.streamId);
         }
         break;
       }
@@ -162,6 +164,13 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
         postMessage({ id, action, result });
         break;
       }
+      case "changeRecoveryIdentifierSignatureText": {
+        const result = await client.changeRecoveryIdentifierSignatureText(
+          data.identifier,
+        );
+        postMessage({ id, action, result });
+        break;
+      }
       case "addEcdsaSignature":
         await client.addEcdsaSignature(data.type, data.bytes);
         postMessage({ id, action, result: undefined });
@@ -258,6 +267,23 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
         postMessage({ id, action, result });
         break;
       }
+      case "getKeyPackageStatusesForInstallationIds": {
+        const result = await client.getKeyPackageStatusesForInstallationIds(
+          data.installationIds,
+        );
+        const safeResult = new Map(
+          Array.from(result.entries()).map(([installationId, status]) => [
+            installationId,
+            toSafeKeyPackageStatus(status),
+          ]),
+        );
+        postMessage({
+          id,
+          action,
+          result: safeResult,
+        });
+        break;
+      }
       /**
        * Conversations actions
        */
@@ -715,6 +741,12 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
         postMessage({ id, action, result });
         break;
       }
+      case "getGroupHmacKeys": {
+        const group = getGroup(data.id);
+        const result = group.getHmacKeys();
+        postMessage({ id, action, result });
+        break;
+      }
     }
   } catch (e) {
     postMessageError({

package/src/workers/utils.ts

@@ -36,9 +36,12 @@ const getInboxIdForIdentifier = async (
   return get_inbox_id_for_identifier(host, identifier);
 };
 
+let enableLogging = false;
+
 self.onmessage = async (event: MessageEvent<UtilsEventsClientMessageData>) => {
   const { action, id, data } = event.data;
-  if (data.enableLogging) {
+
+  if (enableLogging) {
     console.log("utils worker received event data", event.data);
   }
 
@@ -47,6 +50,14 @@ self.onmessage = async (event: MessageEvent<UtilsEventsClientMessageData>) => {
 
   try {
     switch (action) {
+      case "init":
+        enableLogging = data.enableLogging;
+        postMessage({
+          id,
+          action,
+          result: undefined,
+        });
+        break;
       case "generateInboxId":
         postMessage({
           id,
@@ -61,7 +72,6 @@ self.onmessage = async (event: MessageEvent<UtilsEventsClientMessageData>) => {
           result: await getInboxIdForIdentifier(data.identifier, data.env),
         });
         break;
-      // no default
     }
   } catch (e) {
     postMessageError({