@xmtp/browser-sdk 0.0.2 → 0.0.4

package/src/Client.ts

@@ -9,41 +9,48 @@ 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;
-
+  #accountAddress: string;
+  #codecs: Map<string, ContentCodec>;
+  #conversations: Conversations;
+  #encryptionKey: Uint8Array;
   #inboxId: string | undefined;
-
   #installationId: string | undefined;
+  #isReady = false;
+  #signer: Signer;
+  options?: ClientOptions;
 
-  #conversations: Conversations;
-
-  #codecs: Map<string, ContentCodec>;
-
-  constructor(address: string, options?: ClientOptions) {
+  constructor(
+    signer: Signer,
+    accountAddress: string,
+    encryptionKey: Uint8Array,
+    options?: ClientOptions,
+  ) {
     const worker = new Worker(new URL("./workers/client", import.meta.url), {
       type: "module",
     });
-    super(worker, options?.enableLogging ?? false);
-    this.address = address;
+    super(
+      worker,
+      options?.loggingLevel !== undefined && options.loggingLevel !== "off",
+    );
+    this.#accountAddress = accountAddress;
     this.options = options;
+    this.#encryptionKey = encryptionKey;
+    this.#signer = signer;
     this.#conversations = new Conversations(this);
     const codecs = [
       new GroupUpdatedCodec(),
@@ -55,9 +62,14 @@ 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,
     });
     this.#inboxId = result.inboxId;
@@ -65,9 +77,20 @@ export class Client extends ClientWorkerClass {
     this.#isReady = true;
   }
 
-  static async create(address: string, options?: ClientOptions) {
-    const client = new Client(address, options);
+  static async create(
+    signer: Signer,
+    encryptionKey: Uint8Array,
+    options?: ClientOptions,
+  ) {
+    const address = await signer.getAddress();
+    const client = new Client(signer, address, encryptionKey, options);
+
     await client.init();
+
+    if (!options?.disableAutoRegister) {
+      await client.register();
+    }
+
     return client;
   }
 
@@ -83,34 +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 #addAccountSignatureText(newAccountAddress: string) {
+    return this.sendMessage("addAccountSignatureText", {
+      newAccountAddress,
+    });
   }
 
-  async getRevokeWalletSignatureText(accountAddress: string) {
-    return this.sendMessage("getRevokeWalletSignatureText", { accountAddress });
+  async #removeAccountSignatureText(accountAddress: string) {
+    return this.sendMessage("removeAccountSignatureText", { accountAddress });
   }
 
-  async getRevokeInstallationsSignatureText() {
-    return this.sendMessage("getRevokeInstallationsSignatureText", undefined);
+  async #revokeInstallationsSignatureText() {
+    return this.sendMessage("revokeInstallationsSignatureText", undefined);
   }
 
-  async addSignature(type: SignatureRequestType, bytes: Uint8Array) {
-    return this.sendMessage("addSignature", { type, bytes });
+  async #addSignature(
+    signatureType: SignatureRequestType,
+    signatureText: string,
+    signer: Signer,
+  ) {
+    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);
   }
@@ -119,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

@@ -23,9 +23,10 @@ export class WorkerClient {
 
   static async create(
     accountAddress: string,
+    encryptionKey: Uint8Array,
     options?: Omit<ClientOptions, "codecs">,
   ) {
-    const client = await createClient(accountAddress, options);
+    const client = await createClient(accountAddress, encryptionKey, options);
     return new WorkerClient(client);
   }
 
@@ -45,7 +46,7 @@ export class WorkerClient {
     return this.#client.isRegistered;
   }
 
-  async getCreateInboxSignatureText() {
+  async createInboxSignatureText() {
     try {
       return await this.#client.createInboxSignatureText();
     } catch {
@@ -53,7 +54,7 @@ export class WorkerClient {
     }
   }
 
-  async getAddWalletSignatureText(accountAddress: string) {
+  async addAccountSignatureText(accountAddress: string) {
     try {
       return await this.#client.addWalletSignatureText(
         this.#accountAddress,
@@ -64,7 +65,7 @@ export class WorkerClient {
     }
   }
 
-  async getRevokeWalletSignatureText(accountAddress: string) {
+  async removeAccountSignatureText(accountAddress: string) {
     try {
       return await this.#client.revokeWalletSignatureText(accountAddress);
     } catch {
@@ -72,7 +73,7 @@ export class WorkerClient {
     }
   }
 
-  async getRevokeInstallationsSignatureText() {
+  async revokeInstallationsSignatureText() {
     try {
       return await this.#client.revokeInstallationsSignatureText();
     } catch {
@@ -84,6 +85,15 @@ export class WorkerClient {
     return this.#client.addSignature(type, bytes);
   }
 
+  async addScwSignature(
+    type: SignatureRequestType,
+    bytes: Uint8Array,
+    chainId: bigint,
+    blockNumber?: bigint,
+  ) {
+    return this.#client.addScwSignature(type, bytes, chainId, blockNumber);
+  }
+
   async applySignatures() {
     return this.#client.applySignatureRequests();
   }

package/src/WorkerConversation.ts

@@ -2,12 +2,12 @@ import type {
   ConsentState,
   Conversation,
   EncodedContent,
+  GroupMember,
 } from "@xmtp/wasm-bindings";
 import {
   fromSafeListMessagesOptions,
   toSafeGroupMember,
   type SafeListMessagesOptions,
-  type WasmGroupMember,
 } from "@/utils/conversions";
 import type { WorkerClient } from "@/WorkerClient";
 
@@ -73,13 +73,13 @@ export class WorkerConversation {
   get metadata() {
     const metadata = this.#group.groupMetadata();
     return {
-      creatorInboxId: metadata.creator_inbox_id(),
-      conversationType: metadata.conversation_type(),
+      creatorInboxId: metadata.creatorInboxId(),
+      conversationType: metadata.conversationType(),
     };
   }
 
   async members() {
-    const members = (await this.#group.listMembers()) as WasmGroupMember[];
+    const members = (await this.#group.listMembers()) as GroupMember[];
     return members.map((member) => toSafeGroupMember(member));
   }
 

package/src/index.ts

@@ -1,9 +1,41 @@
 export { Client } from "./Client";
 export { Conversations } from "./Conversations";
 export { Conversation } from "./Conversation";
-export * from "./DecodedMessage";
+export type { MessageDeliveryStatus, MessageKind } from "./DecodedMessage";
+export { DecodedMessage } from "./DecodedMessage";
 export { Utils } from "./Utils";
 export { ApiUrls } from "./constants";
 export type * from "./types";
 export * from "./utils/conversions";
-export type * from "@xmtp/wasm-bindings";
+export {
+  ConsentEntityType,
+  ConsentState,
+  ConversationType,
+  CreateGroupOptions,
+  DeliveryStatus,
+  GroupMembershipState,
+  EncodedContent,
+  GroupMember,
+  GroupMetadata,
+  GroupPermissions,
+  GroupMessageKind,
+  GroupPermissionsOptions,
+  InboxState,
+  Installation,
+  ListConversationsOptions,
+  ListMessagesOptions,
+  Message,
+  PermissionLevel,
+  PermissionPolicy,
+  PermissionPolicySet,
+  PermissionUpdateType,
+  SignatureRequestType,
+  SortDirection,
+  Consent,
+  ContentTypeId,
+} from "@xmtp/wasm-bindings";
+export {
+  isSmartContractSigner,
+  type Signer,
+  type SmartContractSigner,
+} from "./utils/signer";

package/src/types/clientEvents.ts

@@ -38,25 +38,26 @@ export type ClientEvents =
       };
       data: {
         address: string;
+        encryptionKey: Uint8Array;
         options?: ClientOptions;
       };
     }
   | {
-      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: {
@@ -64,7 +65,7 @@ export type ClientEvents =
       };
     }
   | {
-      action: "getRevokeInstallationsSignatureText";
+      action: "revokeInstallationsSignatureText";
       id: string;
       result: string | undefined;
       data: undefined;
@@ -78,6 +79,17 @@ export type ClientEvents =
         bytes: Uint8Array;
       };
     }
+  | {
+      action: "addScwSignature";
+      id: string;
+      result: undefined;
+      data: {
+        type: SignatureRequestType;
+        bytes: Uint8Array;
+        chainId: bigint;
+        blockNumber?: bigint;
+      };
+    }
   | {
       action: "applySignatures";
       id: string;

package/src/types/options.ts

@@ -18,16 +18,6 @@ export type NetworkOptions = {
   apiUrl?: string;
 };
 
-/**
- * Encryption options
- */
-export type EncryptionOptions = {
-  /**
-   * Encryption key to use for the local DB
-   */
-  encryptionKey?: Uint8Array;
-};
-
 /**
  * Storage options
  */
@@ -47,13 +37,24 @@ export type ContentOptions = {
 
 export type OtherOptions = {
   /**
-   * Enable logging of events between the client and worker
+   * Enable structured JSON logging
+   */
+  structuredLogging?: boolean;
+  /**
+   * Enable performance metrics
+   */
+  performanceLogging?: boolean;
+  /**
+   * Logging level
+   */
+  loggingLevel?: "off" | "error" | "warn" | "info" | "debug" | "trace";
+  /**
+   * Disable automatic registration when creating a client
    */
-  enableLogging?: boolean;
+  disableAutoRegister?: boolean;
 };
 
 export type ClientOptions = NetworkOptions &
-  EncryptionOptions &
   StorageOptions &
   ContentOptions &
   OtherOptions;

package/src/utils/conversions.ts

@@ -341,36 +341,12 @@ export type SafeGroupMember = {
   permissionLevel: PermissionLevel;
 };
 
-export class WasmGroupMember {
-  account_addresses: string[];
-  consent_state: ConsentState;
-  inbox_id: string;
-  installation_ids: string[];
-  permission_level: PermissionLevel;
-
-  constructor(
-    inbox_id: string,
-    account_addresses: string[],
-    installation_ids: string[],
-    permission_level: PermissionLevel,
-    consent_state: ConsentState,
-  ) {
-    this.inbox_id = inbox_id;
-    this.account_addresses = account_addresses;
-    this.installation_ids = installation_ids;
-    this.permission_level = permission_level;
-    this.consent_state = consent_state;
-  }
-}
-
-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): GroupMember =>

package/src/utils/createClient.ts

@@ -2,12 +2,14 @@ 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
@@ -25,11 +27,25 @@ export const createClient = async (
     (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/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

@@ -56,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,
@@ -67,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,
@@ -76,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,
@@ -87,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({
@@ -98,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,
@@ -115,6 +121,19 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
           result: undefined,
         });
         break;
+      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({