@xmtp/browser-sdk 5.3.0 → 6.0.0

package/src/types/actions/preferences.ts

@@ -1,42 +1,35 @@
 import type {
+  Consent,
   ConsentEntityType,
   ConsentState,
   GroupSyncSummary,
+  InboxState,
 } from "@xmtp/wasm-bindings";
-import type { SafeConsent, SafeInboxState } from "@/utils/conversions";
 
 export type PreferencesAction =
   | {
       action: "preferences.inboxState";
       id: string;
-      result: SafeInboxState;
+      result: InboxState;
       data: {
         refreshFromNetwork: boolean;
       };
     }
   | {
-      action: "preferences.inboxStateFromInboxIds";
+      action: "preferences.getInboxStates";
       id: string;
-      result: SafeInboxState[];
+      result: InboxState[];
       data: {
         inboxIds: string[];
         refreshFromNetwork: boolean;
       };
     }
-  | {
-      action: "preferences.getLatestInboxState";
-      id: string;
-      result: SafeInboxState;
-      data: {
-        inboxId: string;
-      };
-    }
   | {
       action: "preferences.setConsentStates";
       id: string;
       result: undefined;
       data: {
-        records: SafeConsent[];
+        records: Consent[];
       };
     }
   | {

package/src/types/actions/streams.ts

@@ -1,15 +1,15 @@
-import type { UserPreference } from "@xmtp/wasm-bindings";
 import type {
-  SafeConsent,
-  SafeConversation,
-  SafeMessage,
-} from "@/utils/conversions";
+  Consent,
+  DecodedMessage,
+  UserPreferenceUpdate,
+} from "@xmtp/wasm-bindings";
+import type { SafeConversation } from "@/utils/conversions";
 
 export type StreamAction =
   | {
       action: "stream.message";
       streamId: string;
-      result: SafeMessage | undefined;
+      result: DecodedMessage | undefined;
     }
   | {
       action: "stream.conversation";
@@ -19,12 +19,12 @@ export type StreamAction =
   | {
       action: "stream.consent";
       streamId: string;
-      result: SafeConsent[] | undefined;
+      result: Consent[] | undefined;
     }
   | {
       action: "stream.preferences";
       streamId: string;
-      result: UserPreference[] | undefined;
+      result: UserPreferenceUpdate[] | undefined;
     }
   | {
       action: "stream.messageDeleted";

package/src/types/actions.ts

@@ -6,22 +6,24 @@ import type { DmAction } from "@/types/actions/dm";
 import type { GroupAction } from "@/types/actions/group";
 import type { PreferencesAction } from "@/types/actions/preferences";
 
-type UnknownAction = {
+export type UnknownAction = {
   action: string;
   id: string;
   result: unknown;
   data: unknown;
 };
 
+export type EndStreamAction = {
+  action: "endStream";
+  id: string;
+  result: undefined;
+  data: {
+    streamId: string;
+  };
+};
+
 export type ClientWorkerAction =
-  | {
-      action: "endStream";
-      id: string;
-      result: undefined;
-      data: {
-        streamId: string;
-      };
-    }
+  | EndStreamAction
   | ClientAction
   | ConversationAction
   | ConversationsAction

package/src/types/options.ts

@@ -1,5 +1,21 @@
 import type { ContentCodec } from "@xmtp/content-type-primitives";
+import type {
+  Actions,
+  Attachment,
+  EnrichedReply,
+  GroupUpdated,
+  Intent,
+  LeaveRequest,
+  LogLevel,
+  MultiRemoteAttachment,
+  Reaction,
+  ReadReceipt,
+  RemoteAttachment,
+  TransactionReference,
+  WalletSendCalls,
+} from "@xmtp/wasm-bindings";
 import type { ApiUrls } from "@/constants";
+import type { DecodedMessage } from "@/DecodedMessage";
 
 export type XmtpEnv = keyof typeof ApiUrls;
 
@@ -74,7 +90,7 @@ export type OtherOptions = {
   /**
    * Logging level
    */
-  loggingLevel?: "off" | "error" | "warn" | "info" | "debug" | "trace";
+  loggingLevel?: LogLevel;
   /**
    * Disable automatic registration when creating a client
    */
@@ -87,14 +103,39 @@ export type OtherOptions = {
    * Custom app version
    */
   appVersion?: string;
-  /**
-   * Should debug events be tracked
-   * (default: false)
-   */
-  debugEventsEnabled?: boolean;
 };
 
 export type ClientOptions = NetworkOptions &
   ContentOptions &
   StorageOptions &
   OtherOptions;
+
+export type Reply<T = unknown, U = unknown> = {
+  referenceId: EnrichedReply["referenceId"];
+  content: T;
+  inReplyTo: DecodedMessage<U> | null;
+};
+
+export type BuiltInContentTypes =
+  | string // text, markdown
+  | LeaveRequest
+  | Reaction
+  | ReadReceipt
+  | Attachment
+  | RemoteAttachment
+  | TransactionReference
+  | WalletSendCalls
+  | Actions
+  | Intent
+  | MultiRemoteAttachment
+  | GroupUpdated;
+
+export type ExtractCodecContentTypes<C extends ContentCodec[] = []> =
+  C extends readonly []
+    ? BuiltInContentTypes
+    : [...C][number] extends ContentCodec<infer T>
+      ?
+          | T
+          | BuiltInContentTypes
+          | Reply<T | BuiltInContentTypes, T | BuiltInContentTypes>
+      : BuiltInContentTypes;

package/src/{ClientWorkerClass.ts → utils/WorkerBridge.ts}

@@ -1,37 +1,35 @@
-import { v4 } from "uuid";
 import type {
   ActionErrorData,
   ActionName,
   ActionWithoutData,
-  ClientWorkerAction,
+  EndStreamAction,
   ExtractActionData,
   ExtractActionResult,
+  UnknownAction,
 } from "@/types/actions";
 import type {
   StreamAction,
   StreamActionErrorData,
 } from "@/types/actions/streams";
 import type { StreamOptions } from "@/utils/streams";
+import { uuid } from "@/utils/uuid";
 
 const handleError = (event: ErrorEvent) => {
-  console.error(event.message);
+  console.error(`[worker] error: ${event.message}`);
 };
 
 /**
- * Class that sets up a worker and provides communications for client functions
+ * Class that sets up a bridge for worker communications
  *
- * This class is not meant to be used directly, it is extended by the Client class
- * to provide an interface to the worker.
+ * This class is not meant to be used directly.
  *
- * @param worker - The worker to use for the client class
+ * @param worker - The worker to use for communications
  * @param enableLogging - Whether to enable logging in the worker
- * @returns A new ClientWorkerClass instance
+ * @returns A new WorkerBridge instance
  */
-export class ClientWorkerClass {
+export class WorkerBridge<T extends UnknownAction> {
   #worker: Worker;
-
   #enableLogging: boolean;
-
   #promises = new Map<
     string,
     {
@@ -40,31 +38,30 @@ export class ClientWorkerClass {
     }
   >();
 
-  constructor(worker: Worker, enableLogging: boolean) {
+  constructor(worker: Worker, enableLogging?: boolean) {
     this.#worker = worker;
     this.#worker.addEventListener("message", this.handleMessage);
-    if (enableLogging) {
-      this.#worker.addEventListener("error", handleError);
-    }
-    this.#enableLogging = enableLogging;
+    this.#worker.addEventListener("error", handleError);
+    this.#enableLogging = enableLogging ?? false;
   }
 
   /**
-   * Sends an action message to the client worker
+   * Sends an action message to the worker
    *
    * @param action - The action to send to the worker
    * @param data - The data to send to the worker
    * @returns A promise that resolves when the action is completed
    */
-  sendMessage<A extends ActionName<ClientWorkerAction>>(
-    action: A,
-    data: ExtractActionData<ClientWorkerAction, A>,
-  ) {
-    const promiseId = v4();
+  action<
+    A extends ActionName<T>,
+    D = ExtractActionData<T, A>,
+    R = ExtractActionResult<T, A>,
+  >(action: A, ...args: D extends undefined ? [] : [data: D]) {
+    const promiseId = uuid();
     this.#worker.postMessage({
       action,
       id: promiseId,
-      data,
+      data: args[0],
     });
     const promise = new Promise((resolve, reject) => {
       this.#promises.set(promiseId, {
@@ -72,27 +69,20 @@ export class ClientWorkerClass {
         reject,
       });
     });
-    return promise as [ExtractActionResult<ClientWorkerAction, A>] extends [
-      undefined,
-    ]
-      ? Promise<void>
-      : Promise<ExtractActionResult<ClientWorkerAction, A>>;
+    return promise as [R] extends [undefined] ? Promise<void> : Promise<R>;
   }
 
   /**
-   * Handles a message from the client worker
+   * Handles a message from the worker
    *
    * @param event - The event to handle
    */
   handleMessage = (
-    event: MessageEvent<
-      | ActionWithoutData<ClientWorkerAction>
-      | ActionErrorData<ClientWorkerAction>
-    >,
+    event: MessageEvent<ActionWithoutData<T> | ActionErrorData<T>>,
   ) => {
     const eventData = event.data;
     if (this.#enableLogging) {
-      console.log("client received event data", eventData);
+      console.log("[worker] client received event data", eventData);
     }
     const promise = this.#promises.get(eventData.id);
     if (promise) {
@@ -106,16 +96,16 @@ export class ClientWorkerClass {
   };
 
   /**
-   * Handles a stream message from the client worker
+   * Handles a stream message from the worker
    *
    * @param streamId - The ID of the stream to handle
    * @param callback - The callback to handle the stream message
    * @returns A function to remove the stream handler
    */
-  handleStreamMessage = <T extends StreamAction["result"], V = T>(
+  handleStreamMessage = <R extends StreamAction["result"], V = R>(
     streamId: string,
-    callback: (error: Error | null, value: T | undefined) => void,
-    options?: StreamOptions<T, V>,
+    callback: (error: Error | null, value: R | undefined) => void,
+    options?: StreamOptions<R, V>,
   ) => {
     const streamHandler = (
       event: MessageEvent<StreamAction | StreamActionErrorData>,
@@ -131,16 +121,18 @@ export class ClientWorkerClass {
         if ("error" in eventData) {
           callback(eventData.error, undefined);
         } else {
-          callback(null, eventData.result as T);
+          callback(null, eventData.result as R);
         }
       }
     };
     this.#worker.addEventListener("message", streamHandler);
 
     return async () => {
-      await this.sendMessage("endStream", {
-        streamId,
-      });
+      await this.action<
+        "endStream",
+        EndStreamAction["data"],
+        EndStreamAction["result"]
+      >("endStream", { streamId });
       this.#worker.removeEventListener("message", streamHandler);
     };
   };
@@ -150,9 +142,7 @@ export class ClientWorkerClass {
    */
   close() {
     this.#worker.removeEventListener("message", this.handleMessage);
-    if (this.#enableLogging) {
-      this.#worker.removeEventListener("error", handleError);
-    }
+    this.#worker.removeEventListener("error", handleError);
     this.#worker.terminate();
   }
 }

package/src/utils/contentTypes.ts

@@ -0,0 +1,77 @@
+import init, {
+  contentTypeActions as wasmContentTypeActions,
+  contentTypeAttachment as wasmContentTypeAttachment,
+  contentTypeGroupUpdated as wasmContentTypeGroupUpdated,
+  contentTypeIntent as wasmContentTypeIntent,
+  contentTypeLeaveRequest as wasmContentTypeLeaveRequest,
+  contentTypeMarkdown as wasmContentTypeMarkdown,
+  contentTypeMultiRemoteAttachment as wasmContentTypeMultiRemoteAttachment,
+  contentTypeReaction as wasmContentTypeReaction,
+  contentTypeReadReceipt as wasmContentTypeReadReceipt,
+  contentTypeRemoteAttachment as wasmContentTypeRemoteAttachment,
+  contentTypeReply as wasmContentTypeReply,
+  contentTypeText as wasmContentTypeText,
+  contentTypeTransactionReference as wasmContentTypeTransactionReference,
+  contentTypeWalletSendCalls as wasmContentTypeWalletSendCalls,
+  decryptAttachment as wasmDecryptAttachment,
+  encodeActions as wasmEncodeActions,
+  encodeAttachment as wasmEncodeAttachment,
+  encodeIntent as wasmEncodeIntent,
+  encodeMarkdown as wasmEncodeMarkdown,
+  encodeMultiRemoteAttachment as wasmEncodeMultiRemoteAttachment,
+  encodeReaction as wasmEncodeReaction,
+  encodeReadReceipt as wasmEncodeReadReceipt,
+  encodeRemoteAttachment as wasmEncodeRemoteAttachment,
+  encodeText as wasmEncodeText,
+  encodeTransactionReference as wasmEncodeTransactionReference,
+  encodeWalletSendCalls as wasmEncodeWalletSendCalls,
+  encryptAttachment as wasmEncryptAttachment,
+} from "@xmtp/wasm-bindings";
+
+const wrap =
+  <T extends (...args: never[]) => unknown>(fn: T) =>
+  async (...args: Parameters<T>): Promise<ReturnType<T>> => {
+    await init();
+    return fn(...args) as ReturnType<T>;
+  };
+
+// encoders
+export const encodeActions = wrap(wasmEncodeActions);
+export const encodeAttachment = wrap(wasmEncodeAttachment);
+export const encodeIntent = wrap(wasmEncodeIntent);
+export const encodeMarkdown = wrap(wasmEncodeMarkdown);
+export const encodeMultiRemoteAttachment = wrap(
+  wasmEncodeMultiRemoteAttachment,
+);
+export const encodeReaction = wrap(wasmEncodeReaction);
+export const encodeReadReceipt = wrap(wasmEncodeReadReceipt);
+export const encodeRemoteAttachment = wrap(wasmEncodeRemoteAttachment);
+export const encodeText = wrap(wasmEncodeText);
+export const encodeTransactionReference = wrap(wasmEncodeTransactionReference);
+export const encodeWalletSendCalls = wrap(wasmEncodeWalletSendCalls);
+
+// content types
+export const contentTypeActions = wrap(wasmContentTypeActions);
+export const contentTypeAttachment = wrap(wasmContentTypeAttachment);
+export const contentTypeGroupUpdated = wrap(wasmContentTypeGroupUpdated);
+export const contentTypeIntent = wrap(wasmContentTypeIntent);
+export const contentTypeLeaveRequest = wrap(wasmContentTypeLeaveRequest);
+export const contentTypeMarkdown = wrap(wasmContentTypeMarkdown);
+export const contentTypeMultiRemoteAttachment = wrap(
+  wasmContentTypeMultiRemoteAttachment,
+);
+export const contentTypeReaction = wrap(wasmContentTypeReaction);
+export const contentTypeReadReceipt = wrap(wasmContentTypeReadReceipt);
+export const contentTypeRemoteAttachment = wrap(
+  wasmContentTypeRemoteAttachment,
+);
+export const contentTypeReply = wrap(wasmContentTypeReply);
+export const contentTypeText = wrap(wasmContentTypeText);
+export const contentTypeTransactionReference = wrap(
+  wasmContentTypeTransactionReference,
+);
+export const contentTypeWalletSendCalls = wrap(wasmContentTypeWalletSendCalls);
+
+// remote attachment encryption
+export const encryptAttachment = wrap(wasmEncryptAttachment);
+export const decryptAttachment = wrap(wasmDecryptAttachment);