@xmtp/browser-sdk 0.0.3 → 0.0.5

package/src/Client.ts

@@ -9,38 +9,34 @@ import type {
 import { TextCodec } from "@xmtp/content-type-text";
 import {
   GroupMessageKind,
+  SignatureRequestType,
   type ConsentEntityType,
-  type SignatureRequestType,
 } from "@xmtp/wasm-bindings";
 import { ClientWorkerClass } from "@/ClientWorkerClass";
 import { Conversations } from "@/Conversations";
-import type { ClientOptions } from "@/types";
+import type { ClientOptions, XmtpEnv } from "@/types";
 import {
   fromSafeEncodedContent,
   toSafeEncodedContent,
   type SafeConsent,
   type SafeMessage,
 } from "@/utils/conversions";
+import { isSmartContractSigner, type Signer } from "@/utils/signer";
 
 export class Client extends ClientWorkerClass {
-  address: string;
-
-  options?: ClientOptions;
-
-  #isReady = false;
-
-  #inboxId: string | undefined;
-
-  #installationId: string | undefined;
-
-  #conversations: Conversations;
-
+  #accountAddress: string;
   #codecs: Map<string, ContentCodec>;
-
+  #conversations: Conversations;
   #encryptionKey: Uint8Array;
+  #inboxId: string | undefined;
+  #installationId: string | undefined;
+  #isReady = false;
+  #signer: Signer;
+  options?: ClientOptions;
 
   constructor(
-    address: string,
+    signer: Signer,
+    accountAddress: string,
     encryptionKey: Uint8Array,
     options?: ClientOptions,
   ) {
@@ -51,9 +47,10 @@ export class Client extends ClientWorkerClass {
       worker,
       options?.loggingLevel !== undefined && options.loggingLevel !== "off",
     );
-    this.address = address;
+    this.#accountAddress = accountAddress;
     this.options = options;
     this.#encryptionKey = encryptionKey;
+    this.#signer = signer;
     this.#conversations = new Conversations(this);
     const codecs = [
       new GroupUpdatedCodec(),
@@ -65,9 +62,13 @@ export class Client extends ClientWorkerClass {
     );
   }
 
+  get accountAddress() {
+    return this.#accountAddress;
+  }
+
   async init() {
     const result = await this.sendMessage("init", {
-      address: this.address,
+      address: this.accountAddress,
       encryptionKey: this.#encryptionKey,
       options: this.options,
     });
@@ -77,12 +78,19 @@ export class Client extends ClientWorkerClass {
   }
 
   static async create(
-    address: string,
+    signer: Signer,
     encryptionKey: Uint8Array,
     options?: ClientOptions,
   ) {
-    const client = new Client(address, encryptionKey, options);
+    const address = await signer.getAddress();
+    const client = new Client(signer, address, encryptionKey, options);
+
     await client.init();
+
+    if (!options?.disableAutoRegister) {
+      await client.register();
+    }
+
     return client;
   }
 
@@ -98,48 +106,124 @@ export class Client extends ClientWorkerClass {
     return this.#installationId;
   }
 
-  async getCreateInboxSignatureText() {
-    return this.sendMessage("getCreateInboxSignatureText", undefined);
+  async #createInboxSignatureText() {
+    return this.sendMessage("createInboxSignatureText", undefined);
   }
 
-  async getAddWalletSignatureText(accountAddress: string) {
-    return this.sendMessage("getAddWalletSignatureText", { accountAddress });
-  }
-
-  async getRevokeWalletSignatureText(accountAddress: string) {
-    return this.sendMessage("getRevokeWalletSignatureText", { accountAddress });
+  async #addAccountSignatureText(newAccountAddress: string) {
+    return this.sendMessage("addAccountSignatureText", {
+      newAccountAddress,
+    });
   }
 
-  async getRevokeInstallationsSignatureText() {
-    return this.sendMessage("getRevokeInstallationsSignatureText", undefined);
+  async #removeAccountSignatureText(accountAddress: string) {
+    return this.sendMessage("removeAccountSignatureText", { accountAddress });
   }
 
-  async addSignature(type: SignatureRequestType, bytes: Uint8Array) {
-    return this.sendMessage("addSignature", { type, bytes });
+  async #revokeInstallationsSignatureText() {
+    return this.sendMessage("revokeInstallationsSignatureText", undefined);
   }
 
-  async addScwSignature(
-    type: SignatureRequestType,
-    bytes: Uint8Array,
-    chainId: bigint,
-    blockNumber?: bigint,
+  async #addSignature(
+    signatureType: SignatureRequestType,
+    signatureText: string,
+    signer: Signer,
   ) {
-    return this.sendMessage("addScwSignature", {
-      type,
-      bytes,
-      chainId,
-      blockNumber,
-    });
+    const signature = await signer.signMessage(signatureText);
+
+    if (isSmartContractSigner(signer)) {
+      await this.sendMessage("addScwSignature", {
+        type: signatureType,
+        bytes: signature,
+        chainId: signer.getChainId(),
+        blockNumber: signer.getBlockNumber(),
+      });
+    } else {
+      await this.sendMessage("addSignature", {
+        type: signatureType,
+        bytes: signature,
+      });
+    }
   }
 
-  async applySignatures() {
+  async #applySignatures() {
     return this.sendMessage("applySignatures", undefined);
   }
 
-  async registerIdentity() {
+  async register() {
+    const signatureText = await this.#createInboxSignatureText();
+
+    // if the signature text is not available, the client is already registered
+    if (!signatureText) {
+      return;
+    }
+
+    await this.#addSignature(
+      SignatureRequestType.CreateInbox,
+      signatureText,
+      this.#signer,
+    );
+
     return this.sendMessage("registerIdentity", undefined);
   }
 
+  async addAccount(newAccountSigner: Signer) {
+    const signatureText = await this.#addAccountSignatureText(
+      await newAccountSigner.getAddress(),
+    );
+
+    if (!signatureText) {
+      throw new Error("Unable to generate add account signature text");
+    }
+
+    await this.#addSignature(
+      SignatureRequestType.AddWallet,
+      signatureText,
+      this.#signer,
+    );
+
+    await this.#addSignature(
+      SignatureRequestType.AddWallet,
+      signatureText,
+      newAccountSigner,
+    );
+
+    await this.#applySignatures();
+  }
+
+  async removeAccount(accountAddress: string) {
+    const signatureText =
+      await this.#removeAccountSignatureText(accountAddress);
+
+    if (!signatureText) {
+      throw new Error("Unable to generate remove account signature text");
+    }
+
+    await this.#addSignature(
+      SignatureRequestType.RevokeWallet,
+      signatureText,
+      this.#signer,
+    );
+
+    await this.#applySignatures();
+  }
+
+  async revokeInstallations() {
+    const signatureText = await this.#revokeInstallationsSignatureText();
+
+    if (!signatureText) {
+      throw new Error("Unable to generate revoke installations signature text");
+    }
+
+    await this.#addSignature(
+      SignatureRequestType.RevokeInstallations,
+      signatureText,
+      this.#signer,
+    );
+
+    await this.#applySignatures();
+  }
+
   async isRegistered() {
     return this.sendMessage("isRegistered", undefined);
   }
@@ -148,6 +232,23 @@ export class Client extends ClientWorkerClass {
     return this.sendMessage("canMessage", { accountAddresses });
   }
 
+  static async canMessage(accountAddresses: string[], env?: XmtpEnv) {
+    const accountAddress = "0x0000000000000000000000000000000000000000";
+    const signer: Signer = {
+      getAddress: () => accountAddress,
+      signMessage: () => new Uint8Array(),
+    };
+    const client = await Client.create(
+      signer,
+      window.crypto.getRandomValues(new Uint8Array(32)),
+      {
+        disableAutoRegister: true,
+        env,
+      },
+    );
+    return client.canMessage(accountAddresses);
+  }
+
   async findInboxIdByAddress(address: string) {
     return this.sendMessage("findInboxIdByAddress", { address });
   }

package/src/WorkerClient.ts

@@ -46,7 +46,7 @@ export class WorkerClient {
     return this.#client.isRegistered;
   }
 
-  async getCreateInboxSignatureText() {
+  async createInboxSignatureText() {
     try {
       return await this.#client.createInboxSignatureText();
     } catch {
@@ -54,7 +54,7 @@ export class WorkerClient {
     }
   }
 
-  async getAddWalletSignatureText(accountAddress: string) {
+  async addAccountSignatureText(accountAddress: string) {
     try {
       return await this.#client.addWalletSignatureText(
         this.#accountAddress,
@@ -65,7 +65,7 @@ export class WorkerClient {
     }
   }
 
-  async getRevokeWalletSignatureText(accountAddress: string) {
+  async removeAccountSignatureText(accountAddress: string) {
     try {
       return await this.#client.revokeWalletSignatureText(accountAddress);
     } catch {
@@ -73,7 +73,7 @@ export class WorkerClient {
     }
   }
 
-  async getRevokeInstallationsSignatureText() {
+  async revokeInstallationsSignatureText() {
     try {
       return await this.#client.revokeInstallationsSignatureText();
     } catch {

package/src/index.ts

@@ -34,3 +34,8 @@ export {
   Consent,
   ContentTypeId,
 } from "@xmtp/wasm-bindings";
+export {
+  isSmartContractSigner,
+  type Signer,
+  type SmartContractSigner,
+} from "./utils/signer";

package/src/types/clientEvents.ts

@@ -43,21 +43,21 @@ export type ClientEvents =
       };
     }
   | {
-      action: "getCreateInboxSignatureText";
+      action: "createInboxSignatureText";
       id: string;
       result: string | undefined;
       data: undefined;
     }
   | {
-      action: "getAddWalletSignatureText";
+      action: "addAccountSignatureText";
       id: string;
       result: string | undefined;
       data: {
-        accountAddress: string;
+        newAccountAddress: string;
       };
     }
   | {
-      action: "getRevokeWalletSignatureText";
+      action: "removeAccountSignatureText";
       id: string;
       result: string | undefined;
       data: {
@@ -65,7 +65,7 @@ export type ClientEvents =
       };
     }
   | {
-      action: "getRevokeInstallationsSignatureText";
+      action: "revokeInstallationsSignatureText";
       id: string;
       result: string | undefined;
       data: undefined;

package/src/types/options.ts

@@ -48,6 +48,10 @@ export type OtherOptions = {
    * Logging level
    */
   loggingLevel?: "off" | "error" | "warn" | "info" | "debug" | "trace";
+  /**
+   * Disable automatic registration when creating a client
+   */
+  disableAutoRegister?: boolean;
 };
 
 export type ClientOptions = NetworkOptions &

package/src/utils/signer.ts

@@ -0,0 +1,19 @@
+export type SignMessage = (message: string) => Promise<Uint8Array> | Uint8Array;
+export type GetAddress = () => Promise<string> | string;
+export type GetChainId = () => bigint;
+export type GetBlockNumber = () => bigint;
+
+export type Signer = {
+  getAddress: GetAddress;
+  signMessage: SignMessage;
+  // these fields indicate that the signer is a smart contract wallet
+  getBlockNumber?: GetBlockNumber;
+  getChainId?: GetChainId;
+};
+
+export type SmartContractSigner = Required<Signer>;
+
+export const isSmartContractSigner = (
+  signer: Signer,
+): signer is SmartContractSigner =>
+  "getBlockNumber" in signer && "getChainId" in signer;

package/src/workers/client.ts

@@ -73,8 +73,8 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
           },
         });
         break;
-      case "getCreateInboxSignatureText": {
-        const result = await client.getCreateInboxSignatureText();
+      case "createInboxSignatureText": {
+        const result = await client.createInboxSignatureText();
         postMessage({
           id,
           action,
@@ -82,9 +82,9 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
         });
         break;
       }
-      case "getAddWalletSignatureText": {
-        const result = await client.getAddWalletSignatureText(
-          data.accountAddress,
+      case "addAccountSignatureText": {
+        const result = await client.addAccountSignatureText(
+          data.newAccountAddress,
         );
         postMessage({
           id,
@@ -93,8 +93,8 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
         });
         break;
       }
-      case "getRevokeWalletSignatureText": {
-        const result = await client.getRevokeWalletSignatureText(
+      case "removeAccountSignatureText": {
+        const result = await client.removeAccountSignatureText(
           data.accountAddress,
         );
         postMessage({
@@ -104,8 +104,8 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
         });
         break;
       }
-      case "getRevokeInstallationsSignatureText": {
-        const result = await client.getRevokeInstallationsSignatureText();
+      case "revokeInstallationsSignatureText": {
+        const result = await client.revokeInstallationsSignatureText();
         postMessage({
           id,
           action,

package/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "tsconfig/react-sdk.json",
-  "include": ["src", "test", "vite.config.ts", "rollup.config.js"],
-  "compilerOptions": {
-    "paths": {
-      "@/*": ["./src/*"],
-      "@test/*": ["./test/*"]
-    },
-    "types": ["@vitest/browser/providers/playwright"]
-  }
-}