@xmtp/browser-sdk 6.4.1 → 6.5.0

package/src/Client.ts

@@ -1,11 +1,5 @@
 import { type ContentCodec } from "@xmtp/content-type-primitives";
-import {
-  Backend,
-  LogLevel,
-  type ArchiveOptions,
-  type Identifier,
-  type InboxState,
-} from "@xmtp/wasm-bindings";
+import { LogLevel, type Identifier } from "@xmtp/wasm-bindings";
 import { CodecRegistry } from "@/CodecRegistry";
 import { Conversations } from "@/Conversations";
 import { DebugInformation } from "@/DebugInformation";
@@ -16,7 +10,6 @@ import type {
   ExtractCodecContentTypes,
   XmtpEnv,
 } from "@/types/options";
-import { createBackend } from "@/utils/createBackend";
 import {
   AccountAlreadyAssociatedError,
   InboxReassignError,
@@ -29,23 +22,6 @@ import { toSafeSigner, type SafeSigner, type Signer } from "@/utils/signer";
 import { uuid } from "@/utils/uuid";
 import { WorkerBridge } from "@/utils/WorkerBridge";
 
-/**
- * Resolves a `Backend` instance from either a `Backend` or an `XmtpEnv` string.
- *
- * @param envOrBackend - A `Backend` instance, or an `XmtpEnv` string
- * @param gatewayHost - Optional gateway host (only used when `envOrBackend` is an `XmtpEnv`)
- * @returns A `Backend` instance
- */
-const resolveBackend = async (
-  envOrBackend?: XmtpEnv | Backend,
-  gatewayHost?: string,
-): Promise<Backend> => {
-  if (envOrBackend instanceof Backend) {
-    return envOrBackend;
-  }
-  return createBackend({ env: envOrBackend, gatewayHost });
-};
-
 /**
  * Client for interacting with the XMTP network
  */
@@ -54,7 +30,6 @@ export class Client<ContentTypes = ExtractCodecContentTypes> {
   #codecRegistry: CodecRegistry;
   #conversations: Conversations<ContentTypes>;
   #debugInformation: DebugInformation;
-  #env?: XmtpEnv;
   #identifier?: Identifier;
   #inboxId?: string;
   #installationId?: string;
@@ -122,7 +97,6 @@ export class Client<ContentTypes = ExtractCodecContentTypes> {
       options: this.#options,
     });
     this.#appVersion = result.appVersion;
-    this.#env = result.env as XmtpEnv;
     this.#identifier = identifier;
     this.#inboxId = result.inboxId;
     this.#installationId = result.installationId;
@@ -272,13 +246,6 @@ export class Client<ContentTypes = ExtractCodecContentTypes> {
     return this.#appVersion;
   }
 
-  /**
-   * Gets the XMTP environment used by this client
-   */
-  get env() {
-    return this.#env;
-  }
-
   /**
    * Creates signature text for creating a new inbox
    *
@@ -592,27 +559,10 @@ export class Client<ContentTypes = ExtractCodecContentTypes> {
   /**
    * Revokes specific installations of the client's inbox without a client
    *
+   * @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
-   * @param backend - Optional `Backend` instance created with `createBackend()`
-   */
-  static async revokeInstallations(
-    signer: Signer,
-    inboxId: string,
-    installationIds: Uint8Array[],
-    backend?: Backend,
-  ): Promise<void>;
-  /**
-   * Revokes specific installations of the client's inbox without a client
-   *
-   * @param signer - The signer to use
-   * @param inboxId - The inbox ID to revoke installations for
-   * @param installationIds - The installation IDs to revoke
-   * @param env - The environment to use
-   * @param gatewayHost - Optional gateway host
-   * @deprecated Pass a `Backend` instance created with `createBackend()` instead
-   * of `XmtpEnv` and `gatewayHost`.
    */
   static async revokeInstallations(
     signer: Signer,
@@ -620,53 +570,30 @@ export class Client<ContentTypes = ExtractCodecContentTypes> {
     installationIds: Uint8Array[],
     env?: XmtpEnv,
     gatewayHost?: string,
-  ): Promise<void>;
-  static async revokeInstallations(
-    signer: Signer,
-    inboxId: string,
-    installationIds: Uint8Array[],
-    envOrBackend?: XmtpEnv | Backend,
-    gatewayHost?: string,
   ) {
-    const backend = await resolveBackend(envOrBackend, gatewayHost);
-    await utilsRevokeInstallations(backend, signer, inboxId, installationIds);
+    await utilsRevokeInstallations(
+      signer,
+      inboxId,
+      installationIds,
+      env,
+      gatewayHost,
+    );
   }
 
-  /**
-   * Fetches the inbox states for the specified inbox IDs from the network
-   * without a client
-   *
-   * @param inboxIds - The inbox IDs to get the state for
-   * @param backend - Optional `Backend` instance created with `createBackend()`
-   * @returns The inbox states for the specified inbox IDs
-   */
-  static async fetchInboxStates(
-    inboxIds: string[],
-    backend?: Backend,
-  ): Promise<InboxState[]>;
   /**
    * Fetches the inbox states for the specified inbox IDs from the network
    * without a client
    *
    * @param inboxIds - The inbox IDs to get the state for
    * @param env - The environment to use
-   * @param gatewayHost - Optional gateway host
    * @returns The inbox states for the specified inbox IDs
-   * @deprecated Pass a `Backend` instance created with `createBackend()` instead
-   * of `XmtpEnv` and `gatewayHost`.
    */
   static async fetchInboxStates(
     inboxIds: string[],
     env?: XmtpEnv,
     gatewayHost?: string,
-  ): Promise<InboxState[]>;
-  static async fetchInboxStates(
-    inboxIds: string[],
-    envOrBackend?: XmtpEnv | Backend,
-    gatewayHost?: string,
   ) {
-    const backend = await resolveBackend(envOrBackend, gatewayHost);
-    return utilsInboxStateFromInboxIds(backend, inboxIds);
+    return utilsInboxStateFromInboxIds(inboxIds, env, gatewayHost);
   }
 
   /**
@@ -713,40 +640,17 @@ export class Client<ContentTypes = ExtractCodecContentTypes> {
     return this.#worker.action("client.canMessage", { identifiers });
   }
 
-  /**
-   * Checks if the specified identifiers can be messaged
-   *
-   * @param identifiers - The identifiers to check
-   * @param backend - Optional `Backend` instance created with `createBackend()`
-   * @returns Map of identifiers to whether they can be messaged
-   */
-  static async canMessage(
-    identifiers: Identifier[],
-    backend?: Backend,
-  ): Promise<Map<string, boolean>>;
   /**
    * Checks if the specified identifiers can be messaged
    *
    * @param identifiers - The identifiers to check
    * @param env - Optional XMTP environment
    * @returns Map of identifiers to whether they can be messaged
-   * @deprecated Pass a `Backend` instance created with `createBackend()` instead
-   * of `XmtpEnv`.
    */
-  /* eslint-disable @typescript-eslint/unified-signatures */
-  static async canMessage(
-    identifiers: Identifier[],
-    env?: XmtpEnv,
-  ): Promise<Map<string, boolean>>;
-  /* eslint-enable @typescript-eslint/unified-signatures */
-  static async canMessage(
-    identifiers: Identifier[],
-    envOrBackend?: XmtpEnv | Backend,
-  ) {
-    const backend = await resolveBackend(envOrBackend);
+  static async canMessage(identifiers: Identifier[], env?: XmtpEnv) {
     const canMessageMap = new Map<string, boolean>();
     for (const identifier of identifiers) {
-      const inboxId = await getInboxIdForIdentifier(backend, identifier);
+      const inboxId = await getInboxIdForIdentifier(identifier, env);
       canMessageMap.set(
         identifier.identifier.toLowerCase(),
         inboxId !== undefined,
@@ -831,14 +735,9 @@ export class Client<ContentTypes = ExtractCodecContentTypes> {
   /**
    * Send a sync request to other devices on the network
    *
-   * @param options - Archive options specifying what to sync
-   * @param serverUrl - The server URL for the sync request
    * @returns Promise that resolves when the sync request is sent
    */
-  async sendSyncRequest(options: ArchiveOptions, serverUrl: string) {
-    return this.#worker.action("client.sendSyncRequest", {
-      options,
-      serverUrl,
-    });
+  async sendSyncRequest() {
+    return this.#worker.action("client.sendSyncRequest");
   }
 }

package/src/Conversation.ts

@@ -140,6 +140,19 @@ export class Conversation<ContentTypes = unknown> {
     });
   }
 
+  /**
+   * Decodes, decrypts, and persists a raw envelope from a group message stream.
+   *
+   * @param envelopeBytes - Raw protobuf-encoded envelope bytes from the stream
+   * @returns The processed and stored messages
+   */
+  async processStreamedMessage(envelopeBytes: Uint8Array) {
+    return this.#worker.action("conversation.processStreamedMessage", {
+      id: this.#id,
+      envelopeBytes,
+    });
+  }
+
   /**
    * Sends a message
    *

package/src/WorkerClient.ts

@@ -1,12 +1,11 @@
 import {
   verifySignedWithPublicKey,
-  type ArchiveOptions,
   type Client,
   type Identifier,
   type KeyPackageStatus,
   type SignatureRequestHandle,
 } from "@xmtp/wasm-bindings";
-import type { ClientOptions, XmtpEnv } from "@/types/options";
+import type { ClientOptions } from "@/types/options";
 import { createClient } from "@/utils/createClient";
 import type { SafeSigner } from "@/utils/signer";
 import { WorkerConversations } from "@/WorkerConversations";
@@ -17,12 +16,10 @@ export class WorkerClient {
   #client: Client;
   #conversations: WorkerConversations;
   #debugInformation: WorkerDebugInformation;
-  #env: XmtpEnv;
   #preferences: WorkerPreferences;
 
-  constructor(client: Client, env: XmtpEnv) {
+  constructor(client: Client) {
     this.#client = client;
-    this.#env = env;
     const conversations = client.conversations();
     this.#conversations = new WorkerConversations(this, conversations);
     this.#debugInformation = new WorkerDebugInformation(client);
@@ -33,8 +30,8 @@ export class WorkerClient {
     identifier: Identifier,
     options?: Omit<ClientOptions, "codecs">,
   ) {
-    const { client, env } = await createClient(identifier, options);
-    return new WorkerClient(client, env);
+    const client = await createClient(identifier, options);
+    return new WorkerClient(client);
   }
 
   get libxmtpVersion() {
@@ -45,10 +42,6 @@ export class WorkerClient {
     return this.#client.appVersion;
   }
 
-  get env() {
-    return this.#env;
-  }
-
   get accountIdentifier() {
     return this.#client.accountIdentifier;
   }
@@ -151,7 +144,7 @@ export class WorkerClient {
   }
 
   async getInboxIdByIdentifier(identifier: Identifier) {
-    return this.#client.findInboxIdByIdentity(identifier);
+    return this.#client.findInboxIdByIdentifier(identifier);
   }
 
   signWithInstallationKey(signatureText: string) {
@@ -192,7 +185,7 @@ export class WorkerClient {
     ) as Promise<Map<string, KeyPackageStatus>>;
   }
 
-  async sendSyncRequest(options: ArchiveOptions, serverUrl: string) {
-    return this.#client.device_sync().sendSyncRequest(options, serverUrl);
+  async sendSyncRequest() {
+    return this.#client.sendSyncRequest();
   }
 }

package/src/WorkerConversation.ts

@@ -153,19 +153,19 @@ export class WorkerConversation {
   }
 
   async addMembersByIdentifiers(identifiers: Identifier[]) {
-    return this.#group.addMembersByIdentity(identifiers);
+    return this.#group.addMembers(identifiers);
   }
 
   async addMembers(inboxIds: string[]) {
-    return this.#group.addMembers(inboxIds);
+    return this.#group.addMembersByInboxId(inboxIds);
   }
 
   async removeMembersByIdentifiers(identifiers: Identifier[]) {
-    return this.#group.removeMembersByIdentity(identifiers);
+    return this.#group.removeMembers(identifiers);
   }
 
   async removeMembers(inboxIds: string[]) {
-    return this.#group.removeMembers(inboxIds);
+    return this.#group.removeMembersByInboxId(inboxIds);
   }
 
   async addAdmin(inboxId: string) {
@@ -188,6 +188,10 @@ export class WorkerConversation {
     return this.#group.publishMessages();
   }
 
+  async processStreamedMessage(envelopeBytes: Uint8Array) {
+    return this.#group.processStreamedGroupMessage(envelopeBytes);
+  }
+
   async send(encodedContent: EncodedContent, opts?: SendMessageOpts) {
     return this.#group.send(encodedContent, opts ?? { shouldPush: true });
   }

package/src/constants.ts

@@ -1,7 +1,6 @@
 /**
  * Pre-configured URLs for the XMTP network based on the environment
  *
- * @deprecated Use `createBackend()` instead.
  * @constant
  * @property {string} local - The local URL for the XMTP network
  * @property {string} dev - The development URL for the XMTP network
@@ -25,8 +24,4 @@ export const HistorySyncUrls = {
   local: "http://localhost:5558",
   dev: "https://message-history.dev.ephemera.network",
   production: "https://message-history.production.ephemera.network",
-  "testnet-staging": "https://message-history.dev.ephemera.network",
-  "testnet-dev": "https://message-history.dev.ephemera.network",
-  testnet: "https://message-history.dev.ephemera.network",
-  mainnet: "https://message-history.production.ephemera.network",
 } as const;

package/src/index.ts

@@ -5,7 +5,6 @@ export { Conversation } from "./Conversation";
 export { Dm } from "./Dm";
 export { Group } from "./Group";
 export { DecodedMessage } from "./DecodedMessage";
-export { createBackend } from "./utils/createBackend";
 export { generateInboxId, getInboxIdForIdentifier } from "./utils/inboxId";
 export { metadataFieldName } from "./utils/metadata";
 export { ApiUrls, HistorySyncUrls } from "./constants";
@@ -17,10 +16,7 @@ export type {
   Action,
   Actions,
   ApiStats,
-  ArchiveOptions,
   Attachment,
-  Backend,
-  BackendBuilder,
   Consent,
   ConversationDebugInfo,
   ConversationListItem,
@@ -54,6 +50,7 @@ export type {
   Reaction,
   ReadReceipt,
   RemoteAttachment,
+  RemoteAttachmentInfo,
   Reply,
   SendMessageOpts,
   SignatureRequestHandle,
@@ -65,7 +62,6 @@ export type {
 } from "@xmtp/wasm-bindings";
 export {
   ActionStyle,
-  BackupElementSelectionOption,
   ConsentEntityType,
   ConsentState,
   ContentType,

package/src/types/actions/client.ts

@@ -1,8 +1,4 @@
-import type {
-  ArchiveOptions,
-  Identifier,
-  KeyPackageStatus,
-} from "@xmtp/wasm-bindings";
+import type { Identifier, KeyPackageStatus } from "@xmtp/wasm-bindings";
 import type { ClientOptions } from "@/types/options";
 import type { SafeSigner } from "@/utils/signer";
 
@@ -12,7 +8,6 @@ export type ClientAction =
       id: string;
       result: {
         appVersion: string;
-        env: string;
         inboxId: string;
         installationId: string;
         installationIdBytes: Uint8Array;
@@ -221,8 +216,5 @@ export type ClientAction =
       action: "client.sendSyncRequest";
       id: string;
       result: undefined;
-      data: {
-        options: ArchiveOptions;
-        serverUrl: string;
-      };
+      data: undefined;
     };

package/src/types/actions/conversation.ts

@@ -8,6 +8,7 @@ import type {
   GroupMember,
   Intent,
   ListMessagesOptions,
+  Message,
   MessageDisappearingSettings,
   MultiRemoteAttachment,
   Reaction,
@@ -50,6 +51,15 @@ export type ConversationAction =
         id: string;
       };
     }
+  | {
+      action: "conversation.processStreamedMessage";
+      id: string;
+      result: Message[];
+      data: {
+        id: string;
+        envelopeBytes: Uint8Array;
+      };
+    }
   | {
       action: "conversation.messages";
       id: string;

package/src/types/options.ts

@@ -5,7 +5,6 @@ import type {
 import type {
   Actions,
   Attachment,
-  Backend,
   DeletedMessage,
   GroupUpdated,
   Intent,
@@ -18,16 +17,10 @@ import type {
   TransactionReference,
   WalletSendCalls,
 } from "@xmtp/wasm-bindings";
+import type { ApiUrls } from "@/constants";
 import type { DecodedMessage } from "@/DecodedMessage";
 
-export type XmtpEnv =
-  | "local"
-  | "dev"
-  | "production"
-  | "testnet-staging"
-  | "testnet-dev"
-  | "testnet"
-  | "mainnet";
+export type XmtpEnv = keyof typeof ApiUrls;
 
 /**
  * Network options
@@ -42,29 +35,15 @@ export type NetworkOptions = {
    * specific endpoint
    */
   apiUrl?: string;
-  /**
-   * gatewayHost can be used to override the gateway endpoint
-   */
-  gatewayHost?: string;
-  /**
-   * Custom app version
-   */
-  appVersion?: string;
-};
-
-/**
- * Device sync options
- */
-export type DeviceSyncOptions = {
   /**
    * historySyncUrl can be used to override the `env` flag and connect to a
    * specific endpoint for syncing history
    */
   historySyncUrl?: string | null;
   /**
-   * Disable device sync
+   * gatewayHost can be used to override the gateway endpoint
    */
-  disableDeviceSync?: boolean;
+  gatewayHost?: string | null;
 };
 
 export type ContentOptions = {
@@ -119,10 +98,17 @@ export type OtherOptions = {
    * Disable automatic registration when creating a client
    */
   disableAutoRegister?: boolean;
+  /**
+   * Disable device sync
+   */
+  disableDeviceSync?: boolean;
+  /**
+   * Custom app version
+   */
+  appVersion?: string;
 };
 
-export type ClientOptions = (NetworkOptions | { backend: Backend }) &
-  DeviceSyncOptions &
+export type ClientOptions = NetworkOptions &
   ContentOptions &
   StorageOptions &
   OtherOptions;

package/src/utils/createClient.ts

@@ -1,85 +1,51 @@
 import {
-  createClientWithBackend,
-  DeviceSyncMode,
+  createClient as createWasmClient,
+  DeviceSyncWorkerMode,
   generateInboxId,
   getInboxIdForIdentifier,
-  type Backend,
   type Identifier,
 } from "@xmtp/wasm-bindings";
-import type { ClientOptions, NetworkOptions } from "@/types/options";
-import { createBackend, envToString } from "@/utils/createBackend";
-
-const networkOptionKeys = [
-  "env",
-  "apiUrl",
-  "gatewayHost",
-  "appVersion",
-] as const;
-
-const hasBackend = (options: object): options is { backend: Backend } => {
-  return "backend" in options;
-};
-
-const resolveBackend = async (
-  options?: Omit<ClientOptions, "codecs">,
-): Promise<Backend> => {
-  if (!options) {
-    return createBackend();
-  }
-
-  if (hasBackend(options)) {
-    // Validate that no NetworkOptions fields are also set
-    const conflicting = networkOptionKeys.filter(
-      (key) =>
-        key in options && (options as Record<string, unknown>)[key] != null,
-    );
-    if (conflicting.length > 0) {
-      throw new Error(
-        `Cannot specify both 'backend' and network options (${conflicting.join(", ")}). ` +
-          `Use either a pre-built Backend or network options, not both.`,
-      );
-    }
-    return options.backend;
-  }
-
-  // No backend provided — build one from NetworkOptions
-  return createBackend(options as NetworkOptions);
-};
+import { ApiUrls, HistorySyncUrls } from "@/constants";
+import type { ClientOptions } from "@/types/options";
 
 export const createClient = async (
   identifier: Identifier,
   options?: Omit<ClientOptions, "codecs">,
 ) => {
-  const backend = await resolveBackend(options);
-
+  const env = options?.env || "dev";
+  const host = options?.apiUrl || ApiUrls[env];
+  const gatewayHost = options?.gatewayHost || undefined;
+  const isSecure = host.startsWith("https");
   const inboxId =
-    (await getInboxIdForIdentifier(backend, identifier)) ||
+    (await getInboxIdForIdentifier(host, gatewayHost, isSecure, identifier)) ||
     generateInboxId(identifier);
-
-  const envString = envToString(backend.env);
-
   const dbPath =
     options?.dbPath === undefined
-      ? `xmtp-${envString}-${inboxId}.db3`
+      ? `xmtp-${env}-${inboxId}.db3`
       : options.dbPath;
-
   const isLogging =
     options &&
     (options.loggingLevel !== undefined ||
       options.structuredLogging ||
       options.performanceLogging);
 
-  const deviceSyncMode = options?.disableDeviceSync
-    ? DeviceSyncMode.Disabled
-    : DeviceSyncMode.Enabled;
+  const historySyncUrl =
+    options?.historySyncUrl === undefined
+      ? HistorySyncUrls[env]
+      : options.historySyncUrl;
+
+  const deviceSyncWorkerMode = options?.disableDeviceSync
+    ? DeviceSyncWorkerMode.Disabled
+    : DeviceSyncWorkerMode.Enabled;
 
-  const client = await createClientWithBackend(
-    backend,
+  return createWasmClient(
+    host,
     inboxId,
     identifier,
     dbPath,
     options?.dbEncryptionKey,
-    deviceSyncMode,
+    historySyncUrl,
+    deviceSyncWorkerMode,
     isLogging
       ? {
           structured: options.structuredLogging ?? false,
@@ -88,8 +54,11 @@ export const createClient = async (
         }
       : undefined,
     undefined, // allowOffline
+    options?.appVersion,
+    options?.gatewayHost,
     undefined, // nonce
+    undefined, // authCallback
+    undefined, // authHandle
+    undefined, // clientMode
   );
-
-  return { client, env: envString };
 };

package/src/utils/inboxId.ts

@@ -1,9 +1,10 @@
 import init, {
   generateInboxId as wasmGenerateInboxId,
   getInboxIdForIdentifier as wasmGetInboxIdForIdentifier,
-  type Backend,
   type Identifier,
 } from "@xmtp/wasm-bindings";
+import { ApiUrls } from "@/constants";
+import type { XmtpEnv } from "@/types/options";
 
 /**
  * Generates an inbox ID for a given identifier
@@ -21,16 +22,25 @@ export const generateInboxId = async (
 };
 
 /**
- * Gets the inbox ID for a specific identifier using a Backend
+ * Gets the inbox ID for a specific identifier and optional environment
  *
- * @param backend - The Backend instance for API communication
  * @param identifier - The identifier to get the inbox ID for
+ * @param env - Optional XMTP environment configuration (default: "dev")
+ * @param gatewayHost - Optional gateway host override
  * @returns Promise that resolves with the inbox ID for the identifier
  */
 export const getInboxIdForIdentifier = async (
-  backend: Backend,
   identifier: Identifier,
+  env?: XmtpEnv,
+  gatewayHost?: string,
 ): Promise<string | undefined> => {
   await init();
-  return wasmGetInboxIdForIdentifier(backend, identifier);
+  const host = env ? ApiUrls[env] : ApiUrls.dev;
+  const isSecure = host.startsWith("https");
+  return wasmGetInboxIdForIdentifier(
+    host,
+    gatewayHost ?? null,
+    isSecure,
+    identifier,
+  );
 };