@xmtp/browser-sdk 0.0.23 → 1.0.0-rc1

package/src/Client.ts

@@ -11,6 +11,7 @@ import {
   GroupMessageKind,
   SignatureRequestType,
   type ConsentEntityType,
+  type Identifier,
 } from "@xmtp/wasm-bindings";
 import { ClientWorkerClass } from "@/ClientWorkerClass";
 import { Conversations } from "@/Conversations";
@@ -24,7 +25,6 @@ import {
 import { type Signer } from "@/utils/signer";
 
 export class Client extends ClientWorkerClass {
-  #accountAddress: string;
   #codecs: Map<string, ContentCodec>;
   #conversations: Conversations;
   #encryptionKey: Uint8Array;
@@ -37,7 +37,6 @@ export class Client extends ClientWorkerClass {
 
   constructor(
     signer: Signer,
-    accountAddress: string,
     encryptionKey: Uint8Array,
     options?: ClientOptions,
   ) {
@@ -48,7 +47,6 @@ export class Client extends ClientWorkerClass {
       worker,
       options?.loggingLevel !== undefined && options.loggingLevel !== "off",
     );
-    this.#accountAddress = accountAddress;
     this.options = options;
     this.#encryptionKey = encryptionKey;
     this.#signer = signer;
@@ -63,13 +61,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 +78,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 +97,10 @@ export class Client extends ClientWorkerClass {
     return this.#inboxId;
   }
 
+  async accountIdentifier() {
+    return this.#signer.getIdentifier();
+  }
+
   get installationId() {
     return this.#installationId;
   }
@@ -134,7 +131,7 @@ export class Client extends ClientWorkerClass {
    * throw an error.
    */
   async unsafe_addAccountSignatureText(
-    newAccountAddress: string,
+    newIdentifier: Identifier,
     allowInboxReassign: boolean = false,
   ) {
     if (!allowInboxReassign) {
@@ -144,7 +141,7 @@ export class Client extends ClientWorkerClass {
     }
 
     return this.sendMessage("addAccountSignatureText", {
-      newAccountAddress,
+      newIdentifier,
     });
   }
 
@@ -155,8 +152,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 +202,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 +263,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 +274,7 @@ export class Client extends ClientWorkerClass {
     }
 
     const signatureText = await this.unsafe_addAccountSignatureText(
-      await newAccountSigner.getAddress(),
+      await newAccountSigner.getIdentifier(),
       true,
     );
 
@@ -289,9 +291,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 +348,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,11 +369,11 @@ export class Client extends ClientWorkerClass {
         env,
       },
     );
-    return client.canMessage(accountAddresses);
+    return client.canMessage(identifiers);
   }
 
-  async findInboxIdByAddress(address: string) {
-    return this.sendMessage("findInboxIdByAddress", { address });
+  async findInboxIdByIdentifier(identifier: Identifier) {
+    return this.sendMessage("findInboxIdByIdentifier", { identifier });
   }
 
   async inboxState(refreshFromNetwork?: boolean) {

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,6 +1,7 @@
 import {
   ConversationType,
   type ConsentState,
+  type Identifier,
   type UserPreference,
 } from "@xmtp/wasm-bindings";
 import { v4 } from "uuid";
@@ -97,38 +98,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,
     });

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/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

@@ -2,6 +2,7 @@ import {
   verifySignedWithPublicKey,
   type Client,
   type ConsentEntityType,
+  type Identifier,
   type SignatureRequestType,
 } from "@xmtp/wasm-bindings";
 import type { ClientOptions } from "@/types";
@@ -14,25 +15,22 @@ export class WorkerClient {
 
   #conversations: WorkerConversations;
 
-  #accountAddress: string;
-
   constructor(client: Client) {
     this.#client = client;
-    this.#accountAddress = client.accountAddress;
     this.#conversations = new WorkerConversations(this, 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() {
@@ -59,17 +57,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 +91,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 +108,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,8 +118,8 @@ export class WorkerClient {
     return this.#client.registerIdentity();
   }
 
-  async findInboxIdByAddress(address: string) {
-    return this.#client.findInboxIdByAddress(address);
+  async findInboxIdByIdentifier(identifier: Identifier) {
+    return this.#client.findInboxIdByIdentifier(identifier);
   }
 
   async inboxState(refreshFromNetwork: boolean) {

package/src/WorkerConversation.ts

@@ -4,6 +4,7 @@ import {
   type Conversation,
   type EncodedContent,
   type GroupMember,
+  type Identifier,
   type Message,
   type MetadataField,
   type PermissionPolicy,
@@ -121,19 +122,19 @@ export class WorkerConversation {
     return this.#group.sync();
   }
 
-  async addMembers(accountAddresses: string[]) {
-    return this.#group.addMembers(accountAddresses);
+  async addMembersByIdentifiers(identifiers: Identifier[]) {
+    return this.#group.addMembers(identifiers);
   }
 
-  async addMembersByInboxId(inboxIds: string[]) {
+  async addMembers(inboxIds: string[]) {
     return this.#group.addMembersByInboxId(inboxIds);
   }
 
-  async removeMembers(accountAddresses: string[]) {
-    return this.#group.removeMembers(accountAddresses);
+  async removeMembersByIdentifiers(identifiers: Identifier[]) {
+    return this.#group.removeMembers(identifiers);
   }
 
-  async removeMembersByInboxId(inboxIds: string[]) {
+  async removeMembers(inboxIds: string[]) {
     return this.#group.removeMembersByInboxId(inboxIds);
   }
 
@@ -209,4 +210,8 @@ export class WorkerConversation {
     };
     return this.#group.stream({ on_message, on_error });
   }
+
+  pausedForVersion() {
+    return this.#group.pausedForVersion();
+  }
 }

package/src/WorkerConversations.ts

@@ -5,6 +5,7 @@ import {
   type Conversation,
   type ConversationListItem,
   type Conversations,
+  type Identifier,
   type Message,
   type UserPreference,
 } from "@xmtp/wasm-bindings";
@@ -96,18 +97,18 @@ export class WorkerConversations {
     );
   }
 
-  async newGroup(accountAddresses: string[], options?: SafeCreateGroupOptions) {
+  async newGroupWithIdentifiers(
+    identifiers: Identifier[],
+    options?: SafeCreateGroupOptions,
+  ) {
     const group = await this.#conversations.createGroup(
-      accountAddresses,
+      identifiers,
       options ? fromSafeCreateGroupOptions(options) : undefined,
     );
     return new WorkerConversation(this.#client, group);
   }
 
-  async newGroupByInboxIds(
-    inboxIds: string[],
-    options?: SafeCreateGroupOptions,
-  ) {
+  async newGroup(inboxIds: string[], options?: SafeCreateGroupOptions) {
     const group = await this.#conversations.createGroupByInboxIds(
       inboxIds,
       options ? fromSafeCreateGroupOptions(options) : undefined,
@@ -115,15 +116,18 @@ export class WorkerConversations {
     return new WorkerConversation(this.#client, group);
   }
 
-  async newDm(accountAddress: string, options?: SafeCreateDmOptions) {
+  async newDmWithIdentifier(
+    identifier: Identifier,
+    options?: SafeCreateDmOptions,
+  ) {
     const group = await this.#conversations.createDm(
-      accountAddress,
+      identifier,
       options ? fromSafeCreateDmOptions(options) : undefined,
     );
     return new WorkerConversation(this.#client, group);
   }
 
-  async newDmByInboxId(inboxId: string, options?: SafeCreateDmOptions) {
+  async newDm(inboxId: string, options?: SafeCreateDmOptions) {
     const group = await this.#conversations.createDmByInboxId(
       inboxId,
       options ? fromSafeCreateDmOptions(options) : undefined,

package/src/index.ts

@@ -9,7 +9,11 @@ export { Utils } from "./Utils";
 export { ApiUrls, HistorySyncUrls } from "./constants";
 export type * from "./types";
 export * from "./utils/conversions";
-export type { UserPreference } from "@xmtp/wasm-bindings";
+export type {
+  Identifier,
+  IdentifierKind,
+  UserPreference,
+} from "@xmtp/wasm-bindings";
 export {
   Consent,
   ConsentEntityType,