@xmtp/browser-sdk 2.2.1 → 3.0.0

package/src/Utils.ts

@@ -1,5 +1,6 @@
 import type { Identifier } from "@xmtp/wasm-bindings";
 import type { XmtpEnv } from "@/types/options";
+import { toSafeSigner, type Signer } from "@/utils/signer";
 import { UtilsWorkerClass } from "@/UtilsWorkerClass";
 
 /**
@@ -43,4 +44,80 @@ export class Utils extends UtilsWorkerClass {
       env,
     });
   }
+
+  /**
+   * 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
+   * @returns The signature text
+   */
+  async revokeInstallationsSignatureText(
+    identifier: Identifier,
+    inboxId: string,
+    installationIds: Uint8Array[],
+    env?: XmtpEnv,
+  ) {
+    return this.sendMessage("utils.revokeInstallationsSignatureText", {
+      env,
+      identifier,
+      inboxId,
+      installationIds,
+    });
+  }
+
+  /**
+   * 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
+   * @returns Promise that resolves with the result of the revoke installations operation
+   */
+  async revokeInstallations(
+    signer: Signer,
+    inboxId: string,
+    installationIds: Uint8Array[],
+    env?: XmtpEnv,
+  ) {
+    const identifier = await signer.getIdentifier();
+    const signatureText = await this.revokeInstallationsSignatureText(
+      identifier,
+      inboxId,
+      installationIds,
+      env,
+    );
+    const signature = await signer.signMessage(signatureText);
+    const safeSigner = await toSafeSigner(signer, signature);
+
+    return this.sendMessage("utils.revokeInstallations", {
+      signer: safeSigner,
+      inboxId,
+      installationIds,
+      env,
+    });
+  }
+
+  /**
+   * 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) {
+    return this.sendMessage("utils.inboxStateFromInboxIds", {
+      inboxIds,
+      env,
+    });
+  }
 }

package/src/WorkerClient.ts

@@ -3,26 +3,27 @@ import {
   type Client,
   type Identifier,
   type KeyPackageStatus,
-  type SignatureRequestType,
+  type SignatureRequestHandle,
 } from "@xmtp/wasm-bindings";
-import { HistorySyncUrls } from "@/constants";
 import type { ClientOptions } from "@/types/options";
 import { createClient } from "@/utils/createClient";
+import type { SafeSigner } from "@/utils/signer";
 import { WorkerConversations } from "@/WorkerConversations";
+import { WorkerDebugInformation } from "@/WorkerDebugInformation";
 import { WorkerPreferences } from "@/WorkerPreferences";
 
 export class WorkerClient {
   #client: Client;
   #conversations: WorkerConversations;
-  #options?: ClientOptions;
+  #debugInformation: WorkerDebugInformation;
   #preferences: WorkerPreferences;
 
   constructor(client: Client, options?: ClientOptions) {
     this.#client = client;
     const conversations = client.conversations();
     this.#conversations = new WorkerConversations(this, conversations);
+    this.#debugInformation = new WorkerDebugInformation(client, options);
     this.#preferences = new WorkerPreferences(client, conversations);
-    this.#options = options;
   }
 
   static async create(
@@ -57,87 +58,81 @@ export class WorkerClient {
     return this.#conversations;
   }
 
+  get debugInformation() {
+    return this.#debugInformation;
+  }
+
   get preferences() {
     return this.#preferences;
   }
 
-  createInboxSignatureText() {
-    try {
-      return this.#client.createInboxSignatureText();
-    } catch {
-      return undefined;
-    }
+  async canMessage(identifiers: Identifier[]) {
+    return this.#client.canMessage(identifiers) as Promise<
+      Map<string, boolean>
+    >;
   }
 
-  async addAccountSignatureText(identifier: Identifier) {
-    try {
-      return await this.#client.addWalletSignatureText(identifier);
-    } catch {
-      return undefined;
+  async addSignature(
+    signatureRequest: SignatureRequestHandle,
+    signer: SafeSigner,
+  ) {
+    switch (signer.type) {
+      case "SCW":
+        await signatureRequest.addScwSignature(
+          signer.identifier,
+          signer.signature,
+          signer.chainId,
+          signer.blockNumber,
+        );
+        break;
+      case "EOA":
+        await signatureRequest.addEcdsaSignature(signer.signature);
+        break;
     }
   }
 
-  async removeAccountSignatureText(identifier: Identifier) {
-    try {
-      return await this.#client.revokeWalletSignatureText(identifier);
-    } catch {
-      return undefined;
-    }
+  async applySignatureRequest(signatureRequest: SignatureRequestHandle) {
+    return this.#client.applySignatureRequest(signatureRequest);
   }
 
-  async revokeAllAOtherInstallationsSignatureText() {
-    try {
-      return await this.#client.revokeAllOtherInstallationsSignatureText();
-    } catch {
-      return undefined;
-    }
+  async processSignatureRequest(
+    signer: SafeSigner,
+    signatureRequest: SignatureRequestHandle,
+  ) {
+    await this.addSignature(signatureRequest, signer);
+    await this.applySignatureRequest(signatureRequest);
   }
 
-  async revokeInstallationsSignatureText(installationIds: Uint8Array[]) {
-    try {
-      return await this.#client.revokeInstallationsSignatureText(
-        installationIds,
-      );
-    } catch {
-      return undefined;
-    }
+  createInboxSignatureRequest() {
+    return this.#client.createInboxSignatureRequest();
   }
 
-  async changeRecoveryIdentifierSignatureText(identifier: Identifier) {
-    try {
-      return await this.#client.changeRecoveryIdentifierSignatureText(
-        identifier,
-      );
-    } catch {
-      return undefined;
-    }
+  async addAccountSignatureRequest(newAccountIdentifier: Identifier) {
+    return this.#client.addWalletSignatureRequest(newAccountIdentifier);
   }
 
-  async addEcdsaSignature(type: SignatureRequestType, bytes: Uint8Array) {
-    return this.#client.addEcdsaSignature(type, bytes);
+  async removeAccountSignatureRequest(identifier: Identifier) {
+    return this.#client.revokeWalletSignatureRequest(identifier);
   }
 
-  async addScwSignature(
-    type: SignatureRequestType,
-    bytes: Uint8Array,
-    chainId: bigint,
-    blockNumber?: bigint,
-  ) {
-    return this.#client.addScwSignature(type, bytes, chainId, blockNumber);
+  async revokeAllOtherInstallationsSignatureRequest() {
+    return this.#client.revokeAllOtherInstallationsSignatureRequest();
   }
 
-  async applySignatures() {
-    return this.#client.applySignatureRequests();
+  async revokeInstallationsSignatureRequest(installationIds: Uint8Array[]) {
+    return this.#client.revokeInstallationsSignatureRequest(installationIds);
   }
 
-  async canMessage(identifiers: Identifier[]) {
-    return this.#client.canMessage(identifiers) as Promise<
-      Map<string, boolean>
-    >;
+  async changeRecoveryIdentifierSignatureRequest(identifier: Identifier) {
+    return this.#client.changeRecoveryIdentifierSignatureRequest(identifier);
   }
 
-  async registerIdentity() {
-    return this.#client.registerIdentity();
+  async registerIdentity(
+    signer: SafeSigner,
+    signatureRequest: SignatureRequestHandle,
+  ) {
+    await this.addSignature(signatureRequest, signer);
+    await this.#client.registerIdentity(signatureRequest);
   }
 
   async findInboxIdByIdentifier(identifier: Identifier) {
@@ -181,27 +176,4 @@ export class WorkerClient {
       installationIds,
     ) as Promise<Map<string, KeyPackageStatus>>;
   }
-
-  apiStatistics() {
-    return this.#client.apiStatistics();
-  }
-
-  apiIdentityStatistics() {
-    return this.#client.apiIdentityStatistics();
-  }
-
-  apiAggregateStatistics() {
-    return this.#client.apiAggregateStatistics();
-  }
-
-  clearAllStatistics() {
-    this.#client.clearAllStatistics();
-  }
-
-  async uploadDebugArchive(serverUrl?: string) {
-    const env = this.#options?.env || "dev";
-    const historySyncUrl =
-      this.#options?.historySyncUrl || HistorySyncUrls[env];
-    return this.#client.uploadDebugArchive(serverUrl || historySyncUrl);
-  }
 }

package/src/WorkerDebugInformation.ts

@@ -0,0 +1,41 @@
+import type { Client } from "@xmtp/wasm-bindings";
+import { HistorySyncUrls } from "@/constants";
+import type { ClientOptions } from "@/types/options";
+
+/**
+ * Debug information helpers for the client
+ *
+ * This class is not intended to be initialized directly.
+ */
+export class WorkerDebugInformation {
+  #client: Client;
+  #options?: ClientOptions;
+
+  constructor(client: Client, options?: ClientOptions) {
+    this.#client = client;
+    this.#options = options;
+  }
+
+  apiStatistics() {
+    return this.#client.apiStatistics();
+  }
+
+  apiIdentityStatistics() {
+    return this.#client.apiIdentityStatistics();
+  }
+
+  apiAggregateStatistics() {
+    return this.#client.apiAggregateStatistics();
+  }
+
+  clearAllStatistics() {
+    this.#client.clearAllStatistics();
+  }
+
+  uploadDebugArchive(serverUrl?: string) {
+    const env = this.#options?.env || "dev";
+    const historySyncUrl =
+      this.#options?.historySyncUrl || HistorySyncUrls[env];
+    return this.#client.uploadDebugArchive(serverUrl || historySyncUrl);
+  }
+}

package/src/index.ts

@@ -47,8 +47,9 @@ export {
   PermissionPolicy,
   PermissionPolicySet,
   PermissionUpdateType,
-  SignatureRequestType,
+  SignatureRequestHandle,
   SortDirection,
 } from "@xmtp/wasm-bindings";
-export type { Signer } from "./utils/signer";
+export type { Signer, SafeSigner, EOASigner, SCWSigner } from "./utils/signer";
+export { toSafeSigner } from "./utils/signer";
 export * from "./utils/errors";

package/src/types/actions/client.ts

@@ -1,10 +1,7 @@
-import type { Identifier, SignatureRequestType } from "@xmtp/wasm-bindings";
+import type { Identifier } from "@xmtp/wasm-bindings";
 import type { ClientOptions } from "@/types/options";
-import type {
-  SafeApiStats,
-  SafeIdentityStats,
-  SafeKeyPackageStatus,
-} from "@/utils/conversions";
+import type { SafeKeyPackageStatus } from "@/utils/conversions";
+import type { SafeSigner } from "@/utils/signer";
 
 export type ClientAction =
   | {
@@ -20,81 +17,142 @@ export type ClientAction =
         options?: ClientOptions;
       };
     }
+  | {
+      action: "client.applySignatureRequest";
+      id: string;
+      result: undefined;
+      data: {
+        signer: SafeSigner;
+        signatureRequestId: string;
+      };
+    }
   | {
       action: "client.createInboxSignatureText";
       id: string;
-      result: string | undefined;
-      data: undefined;
+      result: {
+        signatureText?: string;
+        signatureRequestId?: string;
+      };
+      data: {
+        signatureRequestId: string;
+      };
     }
   | {
       action: "client.addAccountSignatureText";
       id: string;
-      result: string | undefined;
+      result: {
+        signatureText: string;
+        signatureRequestId: string;
+      };
       data: {
         newIdentifier: Identifier;
+        signatureRequestId: string;
       };
     }
   | {
       action: "client.removeAccountSignatureText";
       id: string;
-      result: string | undefined;
+      result: {
+        signatureText: string;
+        signatureRequestId: string;
+      };
       data: {
         identifier: Identifier;
+        signatureRequestId: string;
       };
     }
   | {
       action: "client.revokeAllOtherInstallationsSignatureText";
       id: string;
-      result: string | undefined;
-      data: undefined;
+      result: {
+        signatureText: string;
+        signatureRequestId: string;
+      };
+      data: {
+        signatureRequestId: string;
+      };
     }
   | {
       action: "client.revokeInstallationsSignatureText";
       id: string;
-      result: string | undefined;
+      result: {
+        signatureText: string;
+        signatureRequestId: string;
+      };
       data: {
         installationIds: Uint8Array[];
+        signatureRequestId: string;
       };
     }
   | {
       action: "client.changeRecoveryIdentifierSignatureText";
       id: string;
-      result: string | undefined;
+      result: {
+        signatureText: string;
+        signatureRequestId: string;
+      };
       data: {
         identifier: Identifier;
+        signatureRequestId: string;
       };
     }
   | {
-      action: "client.addEcdsaSignature";
+      action: "client.registerIdentity";
       id: string;
       result: undefined;
       data: {
-        type: SignatureRequestType;
-        bytes: Uint8Array;
+        signer: SafeSigner;
+        signatureRequestId: string;
       };
     }
   | {
-      action: "client.addScwSignature";
+      action: "client.addAccount";
       id: string;
       result: undefined;
       data: {
-        type: SignatureRequestType;
-        bytes: Uint8Array;
-        chainId: bigint;
-        blockNumber?: bigint;
+        identifier: Identifier;
+        signer: SafeSigner;
+        signatureRequestId: string;
       };
     }
   | {
-      action: "client.applySignatures";
+      action: "client.removeAccount";
       id: string;
       result: undefined;
-      data: undefined;
+      data: {
+        identifier: Identifier;
+        signer: SafeSigner;
+        signatureRequestId: string;
+      };
     }
   | {
-      action: "client.registerIdentity";
+      action: "client.revokeAllOtherInstallations";
       id: string;
       result: undefined;
-      data: undefined;
+      data: {
+        signer: SafeSigner;
+        signatureRequestId: string;
+      };
+    }
+  | {
+      action: "client.changeRecoveryIdentifier";
+      id: string;
+      result: undefined;
+      data: {
+        identifier: Identifier;
+        signer: SafeSigner;
+        signatureRequestId: string;
+      };
+    }
+  | {
+      action: "client.revokeInstallations";
+      id: string;
+      result: undefined;
+      data: {
+        installationIds: Uint8Array[];
+        signer: SafeSigner;
+        signatureRequestId: string;
+      };
     }
   | {
       action: "client.isRegistered";
@@ -152,36 +210,4 @@ export type ClientAction =
       data: {
         installationIds: string[];
       };
-    }
-  | {
-      action: "client.apiStatistics";
-      id: string;
-      result: SafeApiStats;
-      data: undefined;
-    }
-  | {
-      action: "client.apiIdentityStatistics";
-      id: string;
-      result: SafeIdentityStats;
-      data: undefined;
-    }
-  | {
-      action: "client.apiAggregateStatistics";
-      id: string;
-      result: string;
-      data: undefined;
-    }
-  | {
-      action: "client.clearAllStatistics";
-      id: string;
-      result: undefined;
-      data: undefined;
-    }
-  | {
-      action: "client.uploadDebugArchive";
-      id: string;
-      result: string;
-      data: {
-        serverUrl?: string;
-      };
     };

package/src/types/actions/debugInformation.ts

@@ -0,0 +1,35 @@
+import type { SafeApiStats, SafeIdentityStats } from "@/utils/conversions";
+
+export type DebugInformationAction =
+  | {
+      action: "debugInformation.apiStatistics";
+      id: string;
+      result: SafeApiStats;
+      data: undefined;
+    }
+  | {
+      action: "debugInformation.apiIdentityStatistics";
+      id: string;
+      result: SafeIdentityStats;
+      data: undefined;
+    }
+  | {
+      action: "debugInformation.apiAggregateStatistics";
+      id: string;
+      result: string;
+      data: undefined;
+    }
+  | {
+      action: "debugInformation.clearAllStatistics";
+      id: string;
+      result: undefined;
+      data: undefined;
+    }
+  | {
+      action: "debugInformation.uploadDebugArchive";
+      id: string;
+      result: string;
+      data: {
+        serverUrl?: string;
+      };
+    };

package/src/types/actions/utils.ts

@@ -1,5 +1,7 @@
 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 =
   | {
@@ -26,4 +28,35 @@ export type UtilsWorkerAction =
         identifier: Identifier;
         env?: XmtpEnv;
       };
+    }
+  | {
+      action: "utils.revokeInstallationsSignatureText";
+      id: string;
+      result: string;
+      data: {
+        env?: XmtpEnv;
+        identifier: Identifier;
+        inboxId: string;
+        installationIds: Uint8Array[];
+      };
+    }
+  | {
+      action: "utils.revokeInstallations";
+      id: string;
+      result: undefined;
+      data: {
+        env?: XmtpEnv;
+        signer: SafeSigner;
+        inboxId: string;
+        installationIds: Uint8Array[];
+      };
+    }
+  | {
+      action: "utils.inboxStateFromInboxIds";
+      id: string;
+      result: SafeInboxState[];
+      data: {
+        inboxIds: string[];
+        env?: XmtpEnv;
+      };
     };

package/src/types/actions.ts

@@ -1,6 +1,7 @@
 import type { ClientAction } from "@/types/actions/client";
 import type { ConversationAction } from "@/types/actions/conversation";
 import type { ConversationsAction } from "@/types/actions/conversations";
+import type { DebugInformationAction } from "@/types/actions/debugInformation";
 import type { DmAction } from "@/types/actions/dm";
 import type { GroupAction } from "@/types/actions/group";
 import type { PreferencesAction } from "@/types/actions/preferences";
@@ -26,7 +27,8 @@ export type ClientWorkerAction =
   | ConversationsAction
   | DmAction
   | GroupAction
-  | PreferencesAction;
+  | PreferencesAction
+  | DebugInformationAction;
 
 export type ActionName<T extends UnknownAction> = T["action"];
 

package/src/utils/conversions.ts

@@ -403,14 +403,14 @@ export const toSafeInstallation = (
 });
 
 export type SafeInboxState = {
-  accountIdentifiers: Identifier[];
+  identifiers: Identifier[];
   inboxId: string;
   installations: SafeInstallation[];
   recoveryIdentifier: Identifier;
 };
 
 export const toSafeInboxState = (inboxState: InboxState): SafeInboxState => ({
-  accountIdentifiers: inboxState.accountIdentifiers,
+  identifiers: inboxState.accountIdentifiers,
   inboxId: inboxState.inboxId,
   installations: inboxState.installations.map(toSafeInstallation),
   recoveryIdentifier: inboxState.recoveryIdentifier,