@xmtp/browser-sdk 5.2.0 → 6.0.0

package/src/Utils.ts

@@ -1,143 +0,0 @@
-import type { Identifier } from "@xmtp/wasm-bindings";
-import { v4 } from "uuid";
-import type { XmtpEnv } from "@/types/options";
-import { toSafeSigner, type Signer } from "@/utils/signer";
-import { UtilsWorkerClass } from "@/UtilsWorkerClass";
-
-/**
- * Utility class that provides helper functions for XMTP inbox IDs
- */
-export class Utils extends UtilsWorkerClass {
-  /**
-   * Creates a new Utils instance
-   *
-   * @param enableLogging - Optional flag to enable logging
-   */
-  constructor(enableLogging?: boolean) {
-    const worker = new Worker(new URL("./workers/utils", import.meta.url), {
-      type: "module",
-    });
-    super(worker, enableLogging ?? false);
-  }
-
-  /**
-   * Generates an inbox ID for a given identifier
-   *
-   * @param identifier - The identifier to generate an inbox ID for
-   * @returns Promise that resolves with the generated inbox ID
-   */
-  async generateInboxId(identifier: Identifier) {
-    return this.sendMessage("utils.generateInboxId", {
-      identifier,
-    });
-  }
-
-  /**
-   * Gets the inbox ID for a specific identifier and optional environment
-   *
-   * @param identifier - The identifier to get the inbox ID for
-   * @param env - Optional XMTP environment configuration (default: "dev")
-   * @param gatewayHost - Optional gateway host override
-   * @returns Promise that resolves with the inbox ID for the identifier
-   */
-  async getInboxIdForIdentifier(
-    identifier: Identifier,
-    env?: XmtpEnv,
-    gatewayHost?: string,
-  ) {
-    return this.sendMessage("utils.getInboxIdForIdentifier", {
-      identifier,
-      env,
-      gatewayHost,
-    });
-  }
-
-  /**
-   * Creates signature text for revoking installations
-   *
-   * WARNING: This function should be used with caution. It is only provided
-   * for use in special cases where the provided workflows do not meet the
-   * requirements of an application.
-   *
-   * It is highly recommended to use the `revokeInstallations` method instead.
-   *
-   * @param env - The environment to use
-   * @param identifier - The identifier to revoke installations for
-   * @param inboxId - The inbox ID to revoke installations for
-   * @param installationIds - The installation IDs to revoke
-   * @param gatewayHost - Optional gateway host override
-   * @returns The signature text and signature request ID
-   */
-  async revokeInstallationsSignatureText(
-    identifier: Identifier,
-    inboxId: string,
-    installationIds: Uint8Array[],
-    env?: XmtpEnv,
-    gatewayHost?: string,
-  ) {
-    return this.sendMessage("utils.revokeInstallationsSignatureText", {
-      env,
-      identifier,
-      inboxId,
-      installationIds,
-      signatureRequestId: v4(),
-      gatewayHost,
-    });
-  }
-
-  /**
-   * Revokes installations for a given inbox ID
-   *
-   * @param env - The environment to use
-   * @param signer - The signer to use
-   * @param inboxId - The inbox ID to revoke installations for
-   * @param installationIds - The installation IDs to revoke
-   * @param gatewayHost - Optional gateway host override
-   * @returns Promise that resolves with the result of the revoke installations operation
-   */
-  async revokeInstallations(
-    signer: Signer,
-    inboxId: string,
-    installationIds: Uint8Array[],
-    env?: XmtpEnv,
-    gatewayHost?: string,
-  ) {
-    const identifier = await signer.getIdentifier();
-    const { signatureText, signatureRequestId } =
-      await this.revokeInstallationsSignatureText(
-        identifier,
-        inboxId,
-        installationIds,
-        env,
-        gatewayHost,
-      );
-    const signature = await signer.signMessage(signatureText);
-    const safeSigner = await toSafeSigner(signer, signature);
-
-    return this.sendMessage("utils.revokeInstallations", {
-      signer: safeSigner,
-      signatureRequestId,
-      env,
-      gatewayHost,
-    });
-  }
-
-  /**
-   * Gets the inbox state for the specified inbox IDs without a client
-   *
-   * @param inboxIds - The inbox IDs to get the state for
-   * @param env - The environment to use
-   * @returns The inbox state for the specified inbox IDs
-   */
-  async inboxStateFromInboxIds(
-    inboxIds: string[],
-    env?: XmtpEnv,
-    gatewayHost?: string,
-  ) {
-    return this.sendMessage("utils.inboxStateFromInboxIds", {
-      inboxIds,
-      env,
-      gatewayHost,
-    });
-  }
-}

package/src/UtilsWorkerClass.ts

@@ -1,121 +0,0 @@
-import { v4 } from "uuid";
-import type {
-  ActionErrorData,
-  ActionName,
-  ActionWithoutData,
-  ExtractActionData,
-  ExtractActionResult,
-} from "@/types/actions";
-import type { UtilsWorkerAction } from "@/types/actions/utils";
-
-const handleError = (event: ErrorEvent) => {
-  console.error(event.message);
-};
-
-/**
- * Class that sets up a worker and provides communications for utility functions
- *
- * This class is not meant to be used directly, it is extended by the Utils class
- * to provide an interface to the worker.
- *
- * @param worker - The worker to use for the utils class
- * @param enableLogging - Whether to enable logging in the worker
- * @returns A new UtilsWorkerClass instance
- */
-export class UtilsWorkerClass {
-  #worker: Worker;
-
-  #enableLogging: boolean;
-
-  #promises = new Map<
-    string,
-    { resolve: (value: unknown) => void; reject: (reason?: unknown) => void }
-  >();
-
-  constructor(worker: Worker, enableLogging: boolean) {
-    this.#worker = worker;
-    this.#worker.addEventListener("message", this.handleMessage);
-    if (enableLogging) {
-      this.#worker.addEventListener("error", handleError);
-    }
-    this.#enableLogging = enableLogging;
-  }
-
-  /**
-   * Initializes the utils worker
-   *
-   * @param enableLogging - Whether to enable logging in the worker
-   * @returns A promise that resolves when the worker is initialized
-   */
-  async init() {
-    return this.sendMessage("utils.init", {
-      enableLogging: this.#enableLogging,
-    });
-  }
-
-  /**
-   * Sends an action message to the utils worker
-   *
-   * @param action - The action to send to the worker
-   * @param data - The data to send to the worker
-   * @returns A promise that resolves when the action is completed
-   */
-  sendMessage<A extends ActionName<UtilsWorkerAction>>(
-    action: A,
-    data: ExtractActionData<UtilsWorkerAction, A>,
-  ) {
-    const promiseId = v4();
-    this.#worker.postMessage({
-      action,
-      id: promiseId,
-      data,
-    });
-    const promise = new Promise((resolve, reject) => {
-      this.#promises.set(promiseId, {
-        resolve: resolve as (value: unknown) => void,
-        reject,
-      });
-    });
-    return promise as [ExtractActionResult<UtilsWorkerAction, A>] extends [
-      undefined,
-    ]
-      ? Promise<void>
-      : Promise<ExtractActionResult<UtilsWorkerAction, A>>;
-  }
-
-  /**
-   * Handles a message from the utils worker
-   *
-   * @param event - The event to handle
-   */
-  handleMessage = (
-    event: MessageEvent<
-      ActionWithoutData<UtilsWorkerAction> | ActionErrorData<UtilsWorkerAction>
-    >,
-  ) => {
-    const eventData = event.data;
-    if (this.#enableLogging) {
-      console.log("utils received event data", eventData);
-    }
-    const promise = this.#promises.get(eventData.id);
-    if (promise) {
-      this.#promises.delete(eventData.id);
-      if ("error" in eventData) {
-        promise.reject(eventData.error);
-      } else {
-        promise.resolve(eventData.result);
-      }
-    }
-  };
-
-  /**
-   * Removes all event listeners and terminates the worker
-   */
-  close() {
-    this.#worker.removeEventListener("message", this.handleMessage);
-    if (this.#enableLogging) {
-      this.#worker.removeEventListener("error", handleError);
-    }
-    this.#worker.terminate();
-  }
-}

package/src/types/actions/utils.ts

@@ -1,69 +0,0 @@
-import type { Identifier } from "@xmtp/wasm-bindings";
-import type { XmtpEnv } from "@/types/options";
-import type { SafeInboxState } from "@/utils/conversions";
-import type { SafeSigner } from "@/utils/signer";
-
-export type UtilsWorkerAction =
-  | {
-      action: "utils.init";
-      id: string;
-      result: undefined;
-      data: {
-        enableLogging: boolean;
-      };
-    }
-  | {
-      action: "utils.generateInboxId";
-      id: string;
-      result: string;
-      data: {
-        identifier: Identifier;
-      };
-    }
-  | {
-      action: "utils.getInboxIdForIdentifier";
-      id: string;
-      result: string | undefined;
-      data: {
-        identifier: Identifier;
-        env?: XmtpEnv;
-        gatewayHost?: string;
-      };
-    }
-  | {
-      action: "utils.revokeInstallationsSignatureText";
-      id: string;
-      result: {
-        signatureText: string;
-        signatureRequestId: string;
-      };
-      data: {
-        env?: XmtpEnv;
-        identifier: Identifier;
-        inboxId: string;
-        gatewayHost?: string;
-        installationIds: Uint8Array[];
-        signatureRequestId: string;
-      };
-    }
-  | {
-      action: "utils.revokeInstallations";
-      id: string;
-      result: undefined;
-      data: {
-        env?: XmtpEnv;
-        signer: SafeSigner;
-        signatureRequestId: string;
-        gatewayHost?: string;
-      };
-    }
-  | {
-      action: "utils.inboxStateFromInboxIds";
-      id: string;
-      result: SafeInboxState[];
-      data: {
-        inboxIds: string[];
-        env?: XmtpEnv;
-        gatewayHost?: string;
-      };
-    };

package/src/workers/utils.ts

@@ -1,155 +0,0 @@
-import init, {
-  applySignatureRequest,
-  generateInboxId,
-  getInboxIdForIdentifier as get_inbox_id_for_identifier,
-  inboxStateFromInboxIds,
-  revokeInstallationsSignatureRequest,
-  type Identifier,
-  type SignatureRequestHandle,
-} from "@xmtp/wasm-bindings";
-import { ApiUrls } from "@/constants";
-import type {
-  ActionErrorData,
-  ActionName,
-  ActionWithoutResult,
-  ExtractActionWithoutData,
-} from "@/types/actions";
-import type { UtilsWorkerAction } from "@/types/actions/utils";
-import type { XmtpEnv } from "@/types/options";
-import { toSafeInboxState } from "@/utils/conversions";
-
-const signatureRequests = new Map<string, SignatureRequestHandle>();
-
-/**
- * Type-safe postMessage
- */
-const postMessage = <A extends ActionName<UtilsWorkerAction>>(
-  data: ExtractActionWithoutData<UtilsWorkerAction, A>,
-) => {
-  self.postMessage(data);
-};
-
-/**
- * Type-safe postMessage for errors
- */
-const postMessageError = (data: ActionErrorData<UtilsWorkerAction>) => {
-  self.postMessage(data);
-};
-
-const getInboxIdForIdentifier = async (
-  identifier: Identifier,
-  env?: XmtpEnv,
-  gatewayHost?: string,
-) => {
-  const host = env ? ApiUrls[env] : ApiUrls.dev;
-  return get_inbox_id_for_identifier(host, gatewayHost ?? null, identifier);
-};
-
-let enableLogging = false;
-
-self.onmessage = async (
-  event: MessageEvent<ActionWithoutResult<UtilsWorkerAction>>,
-) => {
-  const { action, id, data } = event.data;
-
-  if (enableLogging) {
-    console.log("utils worker received event data", event.data);
-  }
-
-  // initialize WASM module
-  await init();
-
-  try {
-    switch (action) {
-      case "utils.init": {
-        enableLogging = data.enableLogging;
-        postMessage({ id, action, result: undefined });
-        break;
-      }
-      case "utils.generateInboxId": {
-        const result = generateInboxId(data.identifier);
-        postMessage({
-          id,
-          action,
-          result,
-        });
-        break;
-      }
-      case "utils.getInboxIdForIdentifier": {
-        const result = await getInboxIdForIdentifier(
-          data.identifier,
-          data.env,
-          data.gatewayHost,
-        );
-        postMessage({ id, action, result });
-        break;
-      }
-      case "utils.revokeInstallationsSignatureText": {
-        const host = ApiUrls[data.env ?? "dev"];
-        const signatureRequest = revokeInstallationsSignatureRequest(
-          host,
-          data.gatewayHost,
-          data.identifier,
-          data.inboxId,
-          data.installationIds,
-        );
-        const signatureText = await signatureRequest.signatureText();
-        signatureRequests.set(data.signatureRequestId, signatureRequest);
-        const result = {
-          signatureText,
-          signatureRequestId: data.signatureRequestId,
-        };
-        postMessage({ id, action, result });
-        break;
-      }
-      case "utils.revokeInstallations": {
-        const host = ApiUrls[data.env ?? "dev"];
-        const signatureRequest = signatureRequests.get(data.signatureRequestId);
-        if (!signatureRequest) {
-          throw new Error("Signature request not found");
-        }
-        switch (data.signer.type) {
-          case "EOA":
-            await signatureRequest.addEcdsaSignature(data.signer.signature);
-            break;
-          case "SCW":
-            await signatureRequest.addScwSignature(
-              data.signer.identifier,
-              data.signer.signature,
-              data.signer.chainId,
-              data.signer.blockNumber,
-            );
-            break;
-        }
-        await applySignatureRequest(
-          host,
-          data.gatewayHost ?? null,
-          signatureRequest,
-        );
-        signatureRequests.delete(data.signatureRequestId);
-        postMessage({ id, action, result: [] });
-        break;
-      }
-
-      case "utils.inboxStateFromInboxIds": {
-        const host = ApiUrls[data.env ?? "dev"];
-        try {
-          const inboxStates = await inboxStateFromInboxIds(
-            host,
-            data.gatewayHost ?? null,
-            data.inboxIds,
-          );
-          const result = inboxStates.map((inboxState) =>
-            toSafeInboxState(inboxState),
-          );
-          postMessage({ id, action, result });
-        } catch (e) {
-          console.error("utils received error", e);
-        }
-        break;
-      }
-    }
-  } catch (e) {
-    postMessageError({ id, action, error: e as Error });
-  }
-};