@xmtp/browser-sdk 2.0.12 → 2.1.0

package/src/types/actions/streams.ts

@@ -0,0 +1,44 @@
+import type { UserPreference } from "@xmtp/wasm-bindings";
+import type {
+  SafeConsent,
+  SafeConversation,
+  SafeMessage,
+} from "@/utils/conversions";
+
+export type StreamAction =
+  | {
+      action: "stream.message";
+      streamId: string;
+      result: SafeMessage | undefined;
+    }
+  | {
+      action: "stream.conversation";
+      streamId: string;
+      result: SafeConversation | undefined;
+    }
+  | {
+      action: "stream.consent";
+      streamId: string;
+      result: SafeConsent[] | undefined;
+    }
+  | {
+      action: "stream.preferences";
+      streamId: string;
+      result: UserPreference[] | undefined;
+    };
+
+export type StreamActionName = StreamAction["action"];
+
+export type ExtractStreamAction<A extends StreamActionName> = Extract<
+  StreamAction,
+  { action: A }
+>;
+
+export type StreamActionResult<A extends StreamActionName> =
+  ExtractStreamAction<A>["result"];
+
+export type StreamActionErrorData = {
+  action: StreamActionName;
+  error: Error;
+  streamId: string;
+};

package/src/types/actions/utils.ts

@@ -0,0 +1,29 @@
+import type { Identifier } from "@xmtp/wasm-bindings";
+import type { XmtpEnv } from "@/types/options";
+
+export type UtilsWorkerAction =
+  | {
+      action: "utils.init";
+      id: string;
+      result: undefined;
+      data: {
+        enableLogging: boolean;
+      };
+    }
+  | {
+      action: "utils.generateInboxId";
+      id: string;
+      result: string;
+      data: {
+        identifier: Identifier;
+      };
+    }
+  | {
+      action: "utils.getInboxIdForIdentifier";
+      id: string;
+      result: string | undefined;
+      data: {
+        identifier: Identifier;
+        env?: XmtpEnv;
+      };
+    };

package/src/types/actions.ts

@@ -0,0 +1,75 @@
+import type { ClientAction } from "@/types/actions/client";
+import type { ConversationAction } from "@/types/actions/conversation";
+import type { ConversationsAction } from "@/types/actions/conversations";
+import type { DmAction } from "@/types/actions/dm";
+import type { GroupAction } from "@/types/actions/group";
+import type { PreferencesAction } from "@/types/actions/preferences";
+
+type UnknownAction = {
+  action: string;
+  id: string;
+  result: unknown;
+  data: unknown;
+};
+
+export type ClientWorkerAction =
+  | {
+      action: "endStream";
+      id: string;
+      result: undefined;
+      data: {
+        streamId: string;
+      };
+    }
+  | ClientAction
+  | ConversationAction
+  | ConversationsAction
+  | DmAction
+  | GroupAction
+  | PreferencesAction;
+
+export type ActionName<T extends UnknownAction> = T["action"];
+
+export type ExtractAction<
+  T extends UnknownAction,
+  A extends ActionName<T>,
+> = Extract<T, { action: A }>;
+
+export type ExtractActionWithoutData<
+  T extends UnknownAction,
+  A extends ActionName<T>,
+> = Omit<ExtractAction<T, A>, "data">;
+
+export type ExtractActionWithoutResult<
+  T extends UnknownAction,
+  A extends ActionName<T>,
+> = Omit<ExtractAction<T, A>, "result">;
+
+export type ExtractActionData<
+  T extends UnknownAction,
+  A extends ActionName<T>,
+> = ExtractAction<T, A>["data"];
+
+export type ExtractActionResult<
+  T extends UnknownAction,
+  A extends ActionName<T>,
+> = ExtractAction<T, A>["result"];
+
+export type ActionWithoutData<T extends UnknownAction> = {
+  [A in T["action"]]: Omit<Extract<T, { action: A }>, "data">;
+}[T["action"]];
+
+export type ActionWithoutResult<T extends UnknownAction> = {
+  [A in T["action"]]: Omit<Extract<T, { action: A }>, "result">;
+}[T["action"]];
+
+export type ActionErrorData<T extends UnknownAction> = {
+  id: string;
+  action: ActionName<T>;
+  error: Error;
+};
+
+export type ExtractActionGroup<
+  T extends UnknownAction,
+  U extends string,
+> = Extract<T, { action: `${U}.${string}` }>;

package/src/types/options.ts

@@ -36,6 +36,20 @@ export type ContentOptions = {
 export type StorageOptions = {
   /**
    * Path to the local DB
+   *
+   * There are 3 value types that can be used to specify the database path:
+   *
+   * - `undefined` (or excluded from the client options)
+   *    The database will be created in the current working directory and is based on
+   *    the XMTP environment and client inbox ID.
+   *    Example: `xmtp-dev-<inbox-id>.db3`
+   *
+   * - `null`
+   *    No database will be created and all data will be lost once the client disconnects.
+   *
+   * - `string`
+   *    The given path will be used to create the database.
+   *    Example: `./my-db.db3`
    */
   dbPath?: string | null;
   /**
@@ -61,6 +75,10 @@ export type OtherOptions = {
    * Disable automatic registration when creating a client
    */
   disableAutoRegister?: boolean;
+  /**
+   * Disable device sync
+   */
+  disableDeviceSync?: boolean;
 };
 
 export type ClientOptions = NetworkOptions &

package/src/utils/conversions.ts

@@ -14,13 +14,17 @@ import {
   PermissionPolicySet,
   ContentTypeId as WasmContentTypeId,
   EncodedContent as WasmEncodedContent,
+  type ApiStats,
   type ConsentEntityType,
   type ConsentState,
   type ContentType,
+  type ConversationDebugInfo,
+  type ConversationType,
   type DeliveryStatus,
   type GroupMessageKind,
   type HmacKey,
   type Identifier,
+  type IdentityStats,
   type InboxState,
   type Installation,
   type KeyPackageStatus,
@@ -181,6 +185,7 @@ export const fromSafeListMessagesOptions = (
 
 export type SafeListConversationsOptions = {
   consentStates?: ConsentState[];
+  conversationType?: ConversationType;
   createdAfterNs?: bigint;
   createdBeforeNs?: bigint;
   includeDuplicateDms?: boolean;
@@ -191,6 +196,7 @@ export const toSafeListConversationsOptions = (
   options: ListConversationsOptions,
 ): SafeListConversationsOptions => ({
   consentStates: options.consentStates,
+  conversationType: options.conversationType,
   createdAfterNs: options.createdAfterNs,
   createdBeforeNs: options.createdBeforeNs,
   includeDuplicateDms: options.includeDuplicateDms,
@@ -202,6 +208,7 @@ export const fromSafeListConversationsOptions = (
 ): ListConversationsOptions =>
   new ListConversationsOptions(
     options.consentStates,
+    options.conversationType,
     options.createdAfterNs,
     options.createdBeforeNs,
     options.includeDuplicateDms ?? false,
@@ -498,3 +505,56 @@ export const toSafeKeyPackageStatus = (
     : undefined,
   validationError: status.validationError,
 });
+
+export type SafeConversationDebugInfo = {
+  epoch: bigint;
+  maybeForked: boolean;
+  forkDetails: string;
+};
+
+export const toSafeConversationDebugInfo = (
+  debugInfo: ConversationDebugInfo,
+): SafeConversationDebugInfo => ({
+  epoch: debugInfo.epoch,
+  maybeForked: debugInfo.maybeForked,
+  forkDetails: debugInfo.forkDetails,
+});
+
+export type SafeApiStats = {
+  fetchKeyPackage: bigint;
+  queryGroupMessages: bigint;
+  queryWelcomeMessages: bigint;
+  sendGroupMessages: bigint;
+  sendWelcomeMessages: bigint;
+  subscribeMessages: bigint;
+  subscribeWelcomes: bigint;
+  uploadKeyPackage: bigint;
+};
+
+export const toSafeApiStats = (stats: ApiStats): SafeApiStats => ({
+  uploadKeyPackage: stats.upload_key_package,
+  fetchKeyPackage: stats.fetch_key_package,
+  sendGroupMessages: stats.send_group_messages,
+  sendWelcomeMessages: stats.send_welcome_messages,
+  queryGroupMessages: stats.query_group_messages,
+  queryWelcomeMessages: stats.query_welcome_messages,
+  subscribeMessages: stats.subscribe_messages,
+  subscribeWelcomes: stats.subscribe_welcomes,
+});
+
+export type SafeIdentityStats = {
+  getIdentityUpdatesV2: bigint;
+  getInboxIds: bigint;
+  publishIdentityUpdate: bigint;
+  verifySmartContractWalletSignature: bigint;
+};
+
+export const toSafeIdentityStats = (
+  stats: IdentityStats,
+): SafeIdentityStats => ({
+  getIdentityUpdatesV2: stats.get_identity_updates_v2,
+  getInboxIds: stats.get_inbox_ids,
+  publishIdentityUpdate: stats.publish_identity_update,
+  verifySmartContractWalletSignature:
+    stats.verify_smart_contract_wallet_signature,
+});

package/src/utils/createClient.ts

@@ -6,7 +6,7 @@ import {
   type Identifier,
 } from "@xmtp/wasm-bindings";
 import { ApiUrls, HistorySyncUrls } from "@/constants";
-import type { ClientOptions } from "@/types";
+import type { ClientOptions } from "@/types/options";
 
 export const createClient = async (
   identifier: Identifier,
@@ -32,6 +32,10 @@ export const createClient = async (
       ? HistorySyncUrls[env]
       : options.historySyncUrl;
 
+  const deviceSyncWorkerMode = options?.disableDeviceSync
+    ? "disabled"
+    : "enabled";
+
   return createWasmClient(
     host,
     inboxId,
@@ -39,6 +43,7 @@ export const createClient = async (
     dbPath,
     options?.dbEncryptionKey,
     historySyncUrl,
+    deviceSyncWorkerMode,
     isLogging
       ? new LogOptions(
           options.structuredLogging ?? false,

package/src/utils/errors.ts

@@ -3,7 +3,9 @@ import { SignatureRequestType } from "@xmtp/wasm-bindings";
 
 export class ClientNotInitializedError extends Error {
   constructor() {
-    super("Client not initialized");
+    super(
+      "Client not initialized, use Client.create or Client.build to create a client",
+    );
   }
 }