@xmtp/browser-sdk 0.0.23 → 1.0.0

package/src/Client.ts

@@ -10,21 +10,20 @@ import { TextCodec } from "@xmtp/content-type-text";
 import {
   GroupMessageKind,
   SignatureRequestType,
-  type ConsentEntityType,
+  type Identifier,
 } from "@xmtp/wasm-bindings";
 import { ClientWorkerClass } from "@/ClientWorkerClass";
 import { Conversations } from "@/Conversations";
+import { Preferences } from "@/Preferences";
 import type { ClientOptions, XmtpEnv } from "@/types";
 import {
   fromSafeEncodedContent,
   toSafeEncodedContent,
-  type SafeConsent,
   type SafeMessage,
 } from "@/utils/conversions";
 import { type Signer } from "@/utils/signer";
 
 export class Client extends ClientWorkerClass {
-  #accountAddress: string;
   #codecs: Map<string, ContentCodec>;
   #conversations: Conversations;
   #encryptionKey: Uint8Array;
@@ -32,12 +31,12 @@ export class Client extends ClientWorkerClass {
   #installationId: string | undefined;
   #installationIdBytes: Uint8Array | undefined;
   #isReady = false;
+  #preferences: Preferences;
   #signer: Signer;
   options?: ClientOptions;
 
   constructor(
     signer: Signer,
-    accountAddress: string,
     encryptionKey: Uint8Array,
     options?: ClientOptions,
   ) {
@@ -48,11 +47,11 @@ export class Client extends ClientWorkerClass {
       worker,
       options?.loggingLevel !== undefined && options.loggingLevel !== "off",
     );
-    this.#accountAddress = accountAddress;
     this.options = options;
     this.#encryptionKey = encryptionKey;
     this.#signer = signer;
     this.#conversations = new Conversations(this);
+    this.#preferences = new Preferences(this);
     const codecs = [
       new GroupUpdatedCodec(),
       new TextCodec(),
@@ -63,13 +62,9 @@ export class Client extends ClientWorkerClass {
     );
   }
 
-  get accountAddress() {
-    return this.#accountAddress;
-  }
-
   async init() {
     const result = await this.sendMessage("init", {
-      address: this.accountAddress,
+      identifier: await this.#signer.getIdentifier(),
       encryptionKey: this.#encryptionKey,
       options: this.options,
     });
@@ -84,8 +79,7 @@ export class Client extends ClientWorkerClass {
     encryptionKey: Uint8Array,
     options?: ClientOptions,
   ) {
-    const address = await signer.getAddress();
-    const client = new Client(signer, address, encryptionKey, options);
+    const client = new Client(signer, encryptionKey, options);
 
     await client.init();
 
@@ -104,6 +98,10 @@ export class Client extends ClientWorkerClass {
     return this.#inboxId;
   }
 
+  async accountIdentifier() {
+    return this.#signer.getIdentifier();
+  }
+
   get installationId() {
     return this.#installationId;
   }
@@ -112,6 +110,14 @@ export class Client extends ClientWorkerClass {
     return this.#installationIdBytes;
   }
 
+  get conversations() {
+    return this.#conversations;
+  }
+
+  get preferences() {
+    return this.#preferences;
+  }
+
   /**
    * 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
@@ -134,7 +140,7 @@ export class Client extends ClientWorkerClass {
    * throw an error.
    */
   async unsafe_addAccountSignatureText(
-    newAccountAddress: string,
+    newIdentifier: Identifier,
     allowInboxReassign: boolean = false,
   ) {
     if (!allowInboxReassign) {
@@ -144,7 +150,7 @@ export class Client extends ClientWorkerClass {
     }
 
     return this.sendMessage("addAccountSignatureText", {
-      newAccountAddress,
+      newIdentifier,
     });
   }
 
@@ -155,8 +161,10 @@ export class Client extends ClientWorkerClass {
    *
    * It is highly recommended to use the `removeAccount` function instead.
    */
-  async unsafe_removeAccountSignatureText(accountAddress: string) {
-    return this.sendMessage("removeAccountSignatureText", { accountAddress });
+  async unsafe_removeAccountSignatureText(identifier: Identifier) {
+    return this.sendMessage("removeAccountSignatureText", {
+      identifier,
+    });
   }
 
   /**
@@ -203,18 +211,21 @@ export class Client extends ClientWorkerClass {
   ) {
     const signature = await signer.signMessage(signatureText);
 
-    if (signer.walletType === "SCW") {
-      await this.sendMessage("addScwSignature", {
-        type: signatureType,
-        bytes: signature,
-        chainId: signer.getChainId(),
-        blockNumber: signer.getBlockNumber?.(),
-      });
-    } else {
-      await this.sendMessage("addSignature", {
-        type: signatureType,
-        bytes: signature,
-      });
+    switch (signer.type) {
+      case "SCW":
+        await this.sendMessage("addScwSignature", {
+          type: signatureType,
+          bytes: signature,
+          chainId: signer.getChainId(),
+          blockNumber: signer.getBlockNumber?.(),
+        });
+        break;
+      case "EOA":
+        await this.sendMessage("addEcdsaSignature", {
+          type: signatureType,
+          bytes: signature,
+        });
+        break;
     }
   }
 
@@ -261,8 +272,8 @@ export class Client extends ClientWorkerClass {
     allowInboxReassign: boolean = false,
   ) {
     // check for existing inbox id
-    const existingInboxId = await this.findInboxIdByAddress(
-      await newAccountSigner.getAddress(),
+    const existingInboxId = await this.findInboxIdByIdentifier(
+      await newAccountSigner.getIdentifier(),
     );
 
     if (existingInboxId && !allowInboxReassign) {
@@ -272,7 +283,7 @@ export class Client extends ClientWorkerClass {
     }
 
     const signatureText = await this.unsafe_addAccountSignatureText(
-      await newAccountSigner.getAddress(),
+      await newAccountSigner.getIdentifier(),
       true,
     );
 
@@ -289,9 +300,9 @@ export class Client extends ClientWorkerClass {
     await this.unsafe_applySignatures();
   }
 
-  async removeAccount(accountAddress: string) {
+  async removeAccount(accountIdentifier: Identifier) {
     const signatureText =
-      await this.unsafe_removeAccountSignatureText(accountAddress);
+      await this.unsafe_removeAccountSignatureText(accountIdentifier);
 
     if (!signatureText) {
       throw new Error("Unable to generate remove account signature text");
@@ -346,15 +357,17 @@ export class Client extends ClientWorkerClass {
     return this.sendMessage("isRegistered", undefined);
   }
 
-  async canMessage(accountAddresses: string[]) {
-    return this.sendMessage("canMessage", { accountAddresses });
+  async canMessage(identifiers: Identifier[]) {
+    return this.sendMessage("canMessage", { identifiers });
   }
 
-  static async canMessage(accountAddresses: string[], env?: XmtpEnv) {
-    const accountAddress = "0x0000000000000000000000000000000000000000";
+  static async canMessage(identifiers: Identifier[], env?: XmtpEnv) {
     const signer: Signer = {
-      walletType: "EOA",
-      getAddress: () => accountAddress,
+      type: "EOA",
+      getIdentifier: () => ({
+        identifier: "0x0000000000000000000000000000000000000000",
+        identifierKind: "Ethereum",
+      }),
       signMessage: () => new Uint8Array(),
     };
     const client = await Client.create(
@@ -365,33 +378,11 @@ export class Client extends ClientWorkerClass {
         env,
       },
     );
-    return client.canMessage(accountAddresses);
-  }
-
-  async findInboxIdByAddress(address: string) {
-    return this.sendMessage("findInboxIdByAddress", { address });
-  }
-
-  async inboxState(refreshFromNetwork?: boolean) {
-    return this.sendMessage("inboxState", {
-      refreshFromNetwork: refreshFromNetwork ?? false,
-    });
-  }
-
-  async getLatestInboxState(inboxId: string) {
-    return this.sendMessage("getLatestInboxState", { inboxId });
+    return client.canMessage(identifiers);
   }
 
-  async setConsentStates(records: SafeConsent[]) {
-    return this.sendMessage("setConsentStates", { records });
-  }
-
-  async getConsentState(entityType: ConsentEntityType, entity: string) {
-    return this.sendMessage("getConsentState", { entityType, entity });
-  }
-
-  get conversations() {
-    return this.#conversations;
+  async findInboxIdByIdentifier(identifier: Identifier) {
+    return this.sendMessage("findInboxIdByIdentifier", { identifier });
   }
 
   codecFor(contentType: ContentTypeId) {

package/src/Conversation.ts

@@ -199,4 +199,10 @@ export class Conversation {
     };
     return asyncStream;
   }
+
+  async pausedForVersion() {
+    return this.#client.sendMessage("getGroupPausedForVersion", {
+      id: this.#id,
+    });
+  }
 }

package/src/Conversations.ts

@@ -1,7 +1,7 @@
 import {
   ConversationType,
   type ConsentState,
-  type UserPreference,
+  type Identifier,
 } from "@xmtp/wasm-bindings";
 import { v4 } from "uuid";
 import { AsyncStream, type StreamCallback } from "@/AsyncStream";
@@ -10,7 +10,6 @@ import { DecodedMessage } from "@/DecodedMessage";
 import { Dm } from "@/Dm";
 import { Group } from "@/Group";
 import type {
-  SafeConsent,
   SafeConversation,
   SafeCreateDmOptions,
   SafeCreateGroupOptions,
@@ -97,38 +96,47 @@ export class Conversations {
     );
   }
 
-  async newGroup(accountAddresses: string[], options?: SafeCreateGroupOptions) {
-    const conversation = await this.#client.sendMessage("newGroup", {
-      accountAddresses,
-      options,
-    });
+  async newGroupWithIdentifiers(
+    identifiers: Identifier[],
+    options?: SafeCreateGroupOptions,
+  ) {
+    const conversation = await this.#client.sendMessage(
+      "newGroupWithIdentifiers",
+      {
+        identifiers,
+        options,
+      },
+    );
 
     return new Group(this.#client, conversation.id, conversation);
   }
 
-  async newGroupByInboxIds(
-    inboxIds: string[],
-    options?: SafeCreateGroupOptions,
-  ) {
-    const conversation = await this.#client.sendMessage("newGroupByInboxIds", {
-      inboxIds,
-      options,
-    });
+  async newGroup(inboxIds: string[], options?: SafeCreateGroupOptions) {
+    const conversation = await this.#client.sendMessage(
+      "newGroupWithInboxIds",
+      {
+        inboxIds,
+        options,
+      },
+    );
 
     return new Group(this.#client, conversation.id, conversation);
   }
 
-  async newDm(accountAddress: string, options?: SafeCreateDmOptions) {
-    const conversation = await this.#client.sendMessage("newDm", {
-      accountAddress,
+  async newDmWithIdentifier(
+    identifier: Identifier,
+    options?: SafeCreateDmOptions,
+  ) {
+    const conversation = await this.#client.sendMessage("newDmWithIdentifier", {
+      identifier,
       options,
     });
 
     return new Dm(this.#client, conversation.id, conversation);
   }
 
-  async newDmByInboxId(inboxId: string, options?: SafeCreateDmOptions) {
-    const conversation = await this.#client.sendMessage("newDmByInboxId", {
+  async newDm(inboxId: string, options?: SafeCreateDmOptions) {
+    const conversation = await this.#client.sendMessage("newDmWithInboxId", {
       inboxId,
       options,
     });
@@ -231,48 +239,4 @@ export class Conversations {
   async streamAllDmMessages(callback?: StreamCallback<DecodedMessage>) {
     return this.streamAllMessages(callback, ConversationType.Dm);
   }
-
-  async streamConsent(callback?: StreamCallback<SafeConsent[]>) {
-    const streamId = v4();
-    const asyncStream = new AsyncStream<SafeConsent[]>();
-    const endStream = this.#client.handleStreamMessage<SafeConsent[]>(
-      streamId,
-      (error, value) => {
-        void asyncStream.callback(error, value ?? undefined);
-        void callback?.(error, value ?? undefined);
-      },
-    );
-    await this.#client.sendMessage("streamConsent", {
-      streamId,
-    });
-    asyncStream.onReturn = () => {
-      void this.#client.sendMessage("endStream", {
-        streamId,
-      });
-      endStream();
-    };
-    return asyncStream;
-  }
-
-  async streamPreferences(callback?: StreamCallback<UserPreference[]>) {
-    const streamId = v4();
-    const asyncStream = new AsyncStream<UserPreference[]>();
-    const endStream = this.#client.handleStreamMessage<UserPreference[]>(
-      streamId,
-      (error, value) => {
-        void asyncStream.callback(error, value ?? undefined);
-        void callback?.(error, value ?? undefined);
-      },
-    );
-    await this.#client.sendMessage("streamPreferences", {
-      streamId,
-    });
-    asyncStream.onReturn = () => {
-      void this.#client.sendMessage("endStream", {
-        streamId,
-      });
-      endStream();
-    };
-    return asyncStream;
-  }
 }

package/src/Group.ts

@@ -1,4 +1,5 @@
 import type {
+  Identifier,
   MetadataField,
   PermissionPolicy,
   PermissionUpdateType,
@@ -132,28 +133,28 @@ export class Group extends Conversation {
     return superAdmins.includes(inboxId);
   }
 
-  async addMembers(accountAddresses: string[]) {
+  async addMembersByIdentifiers(identifiers: Identifier[]) {
     return this.#client.sendMessage("addGroupMembers", {
       id: this.#id,
-      accountAddresses,
+      identifiers,
     });
   }
 
-  async addMembersByInboxId(inboxIds: string[]) {
+  async addMembers(inboxIds: string[]) {
     return this.#client.sendMessage("addGroupMembersByInboxId", {
       id: this.#id,
       inboxIds,
     });
   }
 
-  async removeMembers(accountAddresses: string[]) {
+  async removeMembersByIdentifiers(identifiers: Identifier[]) {
     return this.#client.sendMessage("removeGroupMembers", {
       id: this.#id,
-      accountAddresses,
+      identifiers,
     });
   }
 
-  async removeMembersByInboxId(inboxIds: string[]) {
+  async removeMembers(inboxIds: string[]) {
     return this.#client.sendMessage("removeGroupMembersByInboxId", {
       id: this.#id,
       inboxIds,

package/src/Preferences.ts

@@ -0,0 +1,75 @@
+import type { ConsentEntityType, UserPreference } from "@xmtp/wasm-bindings";
+import { v4 } from "uuid";
+import { AsyncStream, type StreamCallback } from "@/AsyncStream";
+import type { SafeConsent } from "@/utils/conversions";
+import type { Client } from "./Client";
+
+export class Preferences {
+  #client: Client;
+
+  constructor(client: Client) {
+    this.#client = client;
+  }
+
+  async inboxState(refreshFromNetwork?: boolean) {
+    return this.#client.sendMessage("inboxState", {
+      refreshFromNetwork: refreshFromNetwork ?? false,
+    });
+  }
+
+  async getLatestInboxState(inboxId: string) {
+    return this.#client.sendMessage("getLatestInboxState", { inboxId });
+  }
+
+  async setConsentStates(records: SafeConsent[]) {
+    return this.#client.sendMessage("setConsentStates", { records });
+  }
+
+  async getConsentState(entityType: ConsentEntityType, entity: string) {
+    return this.#client.sendMessage("getConsentState", { entityType, entity });
+  }
+
+  async streamConsent(callback?: StreamCallback<SafeConsent[]>) {
+    const streamId = v4();
+    const asyncStream = new AsyncStream<SafeConsent[]>();
+    const endStream = this.#client.handleStreamMessage<SafeConsent[]>(
+      streamId,
+      (error, value) => {
+        void asyncStream.callback(error, value ?? undefined);
+        void callback?.(error, value ?? undefined);
+      },
+    );
+    await this.#client.sendMessage("streamConsent", {
+      streamId,
+    });
+    asyncStream.onReturn = () => {
+      void this.#client.sendMessage("endStream", {
+        streamId,
+      });
+      endStream();
+    };
+    return asyncStream;
+  }
+
+  async streamPreferences(callback?: StreamCallback<UserPreference[]>) {
+    const streamId = v4();
+    const asyncStream = new AsyncStream<UserPreference[]>();
+    const endStream = this.#client.handleStreamMessage<UserPreference[]>(
+      streamId,
+      (error, value) => {
+        void asyncStream.callback(error, value ?? undefined);
+        void callback?.(error, value ?? undefined);
+      },
+    );
+    await this.#client.sendMessage("streamPreferences", {
+      streamId,
+    });
+    asyncStream.onReturn = () => {
+      void this.#client.sendMessage("endStream", {
+        streamId,
+      });
+      endStream();
+    };
+    return asyncStream;
+  }
+}

package/src/Utils.ts

@@ -1,3 +1,4 @@
+import type { Identifier } from "@xmtp/wasm-bindings";
 import type { XmtpEnv } from "@/types/options";
 import { UtilsWorkerClass } from "@/UtilsWorkerClass";
 
@@ -11,16 +12,16 @@ export class Utils extends UtilsWorkerClass {
     this.#enableLogging = enableLogging ?? false;
   }
 
-  async generateInboxId(address: string) {
+  async generateInboxId(identifier: Identifier) {
     return this.sendMessage("generateInboxId", {
-      address,
+      identifier,
       enableLogging: this.#enableLogging,
     });
   }
 
-  async getInboxIdForAddress(address: string, env?: XmtpEnv) {
-    return this.sendMessage("getInboxIdForAddress", {
-      address,
+  async getInboxIdForIdentifier(identifier: Identifier, env?: XmtpEnv) {
+    return this.sendMessage("getInboxIdForIdentifier", {
+      identifier,
       env,
       enableLogging: this.#enableLogging,
     });

package/src/WorkerClient.ts

@@ -1,38 +1,37 @@
 import {
   verifySignedWithPublicKey,
   type Client,
-  type ConsentEntityType,
+  type Identifier,
   type SignatureRequestType,
 } from "@xmtp/wasm-bindings";
 import type { ClientOptions } from "@/types";
-import { fromSafeConsent, type SafeConsent } from "@/utils/conversions";
 import { createClient } from "@/utils/createClient";
 import { WorkerConversations } from "@/WorkerConversations";
+import { WorkerPreferences } from "@/WorkerPreferences";
 
 export class WorkerClient {
   #client: Client;
-
   #conversations: WorkerConversations;
-
-  #accountAddress: string;
+  #preferences: WorkerPreferences;
 
   constructor(client: Client) {
     this.#client = client;
-    this.#accountAddress = client.accountAddress;
-    this.#conversations = new WorkerConversations(this, client.conversations());
+    const conversations = client.conversations();
+    this.#conversations = new WorkerConversations(this, conversations);
+    this.#preferences = new WorkerPreferences(client, conversations);
   }
 
   static async create(
-    accountAddress: string,
+    identifier: Identifier,
     encryptionKey: Uint8Array,
     options?: Omit<ClientOptions, "codecs">,
   ) {
-    const client = await createClient(accountAddress, encryptionKey, options);
+    const client = await createClient(identifier, encryptionKey, options);
     return new WorkerClient(client);
   }
 
-  get accountAddress() {
-    return this.#accountAddress;
+  get accountIdentifier() {
+    return this.#client.accountIdentifier;
   }
 
   get inboxId() {
@@ -51,6 +50,14 @@ export class WorkerClient {
     return this.#client.isRegistered;
   }
 
+  get conversations() {
+    return this.#conversations;
+  }
+
+  get preferences() {
+    return this.#preferences;
+  }
+
   createInboxSignatureText() {
     try {
       return this.#client.createInboxSignatureText();
@@ -59,17 +66,17 @@ export class WorkerClient {
     }
   }
 
-  async addAccountSignatureText(accountAddress: string) {
+  async addAccountSignatureText(identifier: Identifier) {
     try {
-      return await this.#client.addWalletSignatureText(accountAddress);
+      return await this.#client.addWalletSignatureText(identifier);
     } catch {
       return undefined;
     }
   }
 
-  async removeAccountSignatureText(accountAddress: string) {
+  async removeAccountSignatureText(identifier: Identifier) {
     try {
-      return await this.#client.revokeWalletSignatureText(accountAddress);
+      return await this.#client.revokeWalletSignatureText(identifier);
     } catch {
       return undefined;
     }
@@ -93,8 +100,8 @@ export class WorkerClient {
     }
   }
 
-  async addSignature(type: SignatureRequestType, bytes: Uint8Array) {
-    return this.#client.addSignature(type, bytes);
+  async addEcdsaSignature(type: SignatureRequestType, bytes: Uint8Array) {
+    return this.#client.addEcdsaSignature(type, bytes);
   }
 
   async addScwSignature(
@@ -110,8 +117,8 @@ export class WorkerClient {
     return this.#client.applySignatureRequests();
   }
 
-  async canMessage(accountAddresses: string[]) {
-    return this.#client.canMessage(accountAddresses) as Promise<
+  async canMessage(identifiers: Identifier[]) {
+    return this.#client.canMessage(identifiers) as Promise<
       Map<string, boolean>
     >;
   }
@@ -120,28 +127,8 @@ export class WorkerClient {
     return this.#client.registerIdentity();
   }
 
-  async findInboxIdByAddress(address: string) {
-    return this.#client.findInboxIdByAddress(address);
-  }
-
-  async inboxState(refreshFromNetwork: boolean) {
-    return this.#client.inboxState(refreshFromNetwork);
-  }
-
-  async getLatestInboxState(inboxId: string) {
-    return this.#client.getLatestInboxState(inboxId);
-  }
-
-  async setConsentStates(records: SafeConsent[]) {
-    return this.#client.setConsentStates(records.map(fromSafeConsent));
-  }
-
-  async getConsentState(entityType: ConsentEntityType, entity: string) {
-    return this.#client.getConsentState(entityType, entity);
-  }
-
-  get conversations() {
-    return this.#conversations;
+  async findInboxIdByIdentifier(identifier: Identifier) {
+    return this.#client.findInboxIdByIdentifier(identifier);
   }
 
   signWithInstallationKey(signatureText: string) {