@xmtp/browser-sdk 5.3.0 → 6.0.1

package/src/Conversation.ts

@@ -1,21 +1,31 @@
-import type { ContentTypeId } from "@xmtp/content-type-primitives";
-import { ContentTypeText } from "@xmtp/content-type-text";
-import type { ConsentState } from "@xmtp/wasm-bindings";
-import { v4 } from "uuid";
-import type { Client } from "@/Client";
+import {
+  type Actions,
+  type Attachment,
+  type ConsentState,
+  type EncodedContent,
+  type Intent,
+  type ListMessagesOptions,
+  type MultiRemoteAttachment,
+  type Reaction,
+  type RemoteAttachment,
+  type Reply,
+  type SendMessageOpts,
+  type TransactionReference,
+  type WalletSendCalls,
+  type DecodedMessage as XmtpDecodedMessage,
+} from "@xmtp/wasm-bindings";
+import type { CodecRegistry } from "@/CodecRegistry";
 import { DecodedMessage } from "@/DecodedMessage";
-import type {
-  SafeConversation,
-  SafeListMessagesOptions,
-  SafeMessage,
-} from "@/utils/conversions";
+import type { ClientWorkerAction } from "@/types/actions";
+import type { SafeConversation } from "@/utils/conversions";
 import { nsToDate } from "@/utils/date";
-import { MissingContentTypeError } from "@/utils/errors";
 import {
   createStream,
   type StreamCallback,
   type StreamOptions,
 } from "@/utils/streams";
+import { uuid } from "@/utils/uuid";
+import type { WorkerBridge } from "@/utils/WorkerBridge";
 
 /**
  * Represents a conversation
@@ -24,25 +34,28 @@ import {
  */
 export class Conversation<ContentTypes = unknown> {
   #addedByInboxId?: SafeConversation["addedByInboxId"];
-  #client: Client<ContentTypes>;
+  #codecRegistry: CodecRegistry;
   #createdAtNs?: SafeConversation["createdAtNs"];
   #id: string;
   #metadata?: SafeConversation["metadata"];
-  #isCommitLogForked?: SafeConversation["isCommitLogForked"];
+  #worker: WorkerBridge<ClientWorkerAction>;
 
   /**
    * Creates a new conversation instance
    *
-   * @param client - The client instance managing the conversation
+   * @param worker - The worker bridge instance for client communication
+   * @param codecRegistry - The codec registry instance
    * @param id - The unique identifier for this conversation
    * @param data - Optional conversation data to initialize with
    */
   constructor(
-    client: Client<ContentTypes>,
+    worker: WorkerBridge<ClientWorkerAction>,
+    codecRegistry: CodecRegistry,
     id: string,
     data?: SafeConversation,
   ) {
-    this.#client = client;
+    this.#worker = worker;
+    this.#codecRegistry = codecRegistry;
     this.#id = id;
     this.#syncData(data);
   }
@@ -51,17 +64,12 @@ export class Conversation<ContentTypes = unknown> {
     this.#addedByInboxId = data?.addedByInboxId;
     this.#metadata = data?.metadata;
     this.#createdAtNs = data?.createdAtNs;
-    this.#isCommitLogForked = data?.isCommitLogForked;
   }
 
   get id() {
     return this.#id;
   }
 
-  get isCommitLogForked() {
-    return this.#isCommitLogForked;
-  }
-
   get addedByInboxId() {
     return this.#addedByInboxId;
   }
@@ -79,19 +87,16 @@ export class Conversation<ContentTypes = unknown> {
   }
 
   async lastMessage() {
-    const lastMessage = await this.#client.sendMessage(
-      "conversation.lastMessage",
-      {
-        id: this.#id,
-      },
-    );
+    const lastMessage = await this.#worker.action("conversation.lastMessage", {
+      id: this.#id,
+    });
     return lastMessage
-      ? new DecodedMessage(this.#client, lastMessage)
+      ? new DecodedMessage<ContentTypes>(this.#codecRegistry, lastMessage)
       : undefined;
   }
 
   async isActive() {
-    return this.#client.sendMessage("conversation.isActive", {
+    return this.#worker.action("conversation.isActive", {
       id: this.#id,
     });
   }
@@ -102,7 +107,7 @@ export class Conversation<ContentTypes = unknown> {
    * @returns Promise that resolves with the conversation members
    */
   async members() {
-    return this.#client.sendMessage("conversation.members", {
+    return this.#worker.action("conversation.members", {
       id: this.#id,
     });
   }
@@ -113,7 +118,7 @@ export class Conversation<ContentTypes = unknown> {
    * @returns Promise that resolves with the updated conversation data
    */
   async sync() {
-    const data = await this.#client.sendMessage("conversation.sync", {
+    const data = await this.#worker.action("conversation.sync", {
       id: this.#id,
     });
     this.#syncData(data);
@@ -126,60 +131,217 @@ export class Conversation<ContentTypes = unknown> {
    * @returns Promise that resolves when publishing is complete
    */
   async publishMessages() {
-    return this.#client.sendMessage("conversation.publishMessages", {
+    return this.#worker.action("conversation.publishMessages", {
+      id: this.#id,
+    });
+  }
+
+  /**
+   * Sends a message
+   *
+   * @param content - The encoded content to send
+   * @param options - Optional send options
+   * @param options.shouldPush - Indicates whether this message should be
+   * included in push notifications
+   * @param options.isOptimistic - Indicates whether this message should be
+   * sent optimistically and published later via `publishMessages`
+   * @returns Promise that resolves with the message ID after it has been sent
+   */
+  async send(content: EncodedContent, options?: SendMessageOpts) {
+    return this.#worker.action("conversation.send", {
+      id: this.#id,
+      content,
+      options,
+    });
+  }
+
+  /**
+   * Sends a text message
+   *
+   * @param text - The text to send
+   * @param isOptimistic - Whether to send the message optimistically
+   * @returns Promise that resolves with the message ID after it has been sent
+   */
+  async sendText(text: string, isOptimistic?: boolean) {
+    return this.#worker.action("conversation.sendText", {
+      id: this.#id,
+      text,
+      isOptimistic,
+    });
+  }
+
+  /**
+   * Sends a markdown message
+   *
+   * @param markdown - The markdown to send
+   * @param isOptimistic - Whether to send the message optimistically
+   * @returns Promise that resolves with the message ID after it has been sent
+   */
+  async sendMarkdown(markdown: string, isOptimistic?: boolean) {
+    return this.#worker.action("conversation.sendMarkdown", {
+      id: this.#id,
+      markdown,
+      isOptimistic,
+    });
+  }
+
+  /**
+   * Sends a reaction message
+   *
+   * @param reaction - The reaction to send
+   * @param isOptimistic - Whether to send the message optimistically
+   * @returns Promise that resolves with the message ID after it has been sent
+   */
+  async sendReaction(reaction: Reaction, isOptimistic?: boolean) {
+    return this.#worker.action("conversation.sendReaction", {
       id: this.#id,
+      reaction,
+      isOptimistic,
     });
   }
 
   /**
-   * Prepares a message to be published
+   * Sends a read receipt message
    *
-   * @param content - The content to send
-   * @param contentType - Optional content type of the message content
-   * @returns Promise that resolves with the message ID
-   * @throws {MissingContentTypeError} if content type is required but not provided
+   * @param isOptimistic - Whether to send the message optimistically
+   * @returns Promise that resolves with the message ID after it has been sent
    */
-  async sendOptimistic(content: ContentTypes, contentType?: ContentTypeId) {
-    if (typeof content !== "string" && !contentType) {
-      throw new MissingContentTypeError();
-    }
-
-    const { encodedContent: safeEncodedContent, sendOptions } =
-      typeof content === "string"
-        ? this.#client.prepareForSend(content, contentType ?? ContentTypeText)
-        : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          this.#client.prepareForSend(content, contentType!);
-
-    return this.#client.sendMessage("conversation.sendOptimistic", {
+  async sendReadReceipt(isOptimistic?: boolean) {
+    return this.#worker.action("conversation.sendReadReceipt", {
       id: this.#id,
-      content: safeEncodedContent,
-      sendOptions,
+      isOptimistic,
     });
   }
 
   /**
-   * Publishes a new message
+   * Sends a reply message
    *
-   * @param content - The content to send
-   * @param contentType - Optional content type of the message content
+   * @param reply - The reply to send
+   * @param isOptimistic - Whether to send the message optimistically
    * @returns Promise that resolves with the message ID after it has been sent
-   * @throws {MissingContentTypeError} if content type is required but not provided
    */
-  async send(content: ContentTypes, contentType?: ContentTypeId) {
-    if (typeof content !== "string" && !contentType) {
-      throw new MissingContentTypeError();
-    }
-
-    const { encodedContent: safeEncodedContent, sendOptions } =
-      typeof content === "string"
-        ? this.#client.prepareForSend(content, contentType ?? ContentTypeText)
-        : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          this.#client.prepareForSend(content, contentType!);
-
-    return this.#client.sendMessage("conversation.send", {
+  async sendReply(reply: Reply, isOptimistic?: boolean) {
+    return this.#worker.action("conversation.sendReply", {
       id: this.#id,
-      content: safeEncodedContent,
-      sendOptions,
+      reply,
+      isOptimistic,
+    });
+  }
+
+  /**
+   * Sends a transaction reference message
+   *
+   * @param transactionReference - The transaction reference to send
+   * @param isOptimistic - Whether to send the message optimistically
+   * @returns Promise that resolves with the message ID after it has been sent
+   */
+  async sendTransactionReference(
+    transactionReference: TransactionReference,
+    isOptimistic?: boolean,
+  ) {
+    return this.#worker.action("conversation.sendTransactionReference", {
+      id: this.#id,
+      transactionReference,
+      isOptimistic,
+    });
+  }
+
+  /**
+   * Sends a wallet send calls message
+   *
+   * @param walletSendCalls - The wallet send calls to send
+   * @param isOptimistic - Whether to send the message optimistically
+   * @returns Promise that resolves with the message ID after it has been sent
+   */
+  async sendWalletSendCalls(
+    walletSendCalls: WalletSendCalls,
+    isOptimistic?: boolean,
+  ) {
+    return this.#worker.action("conversation.sendWalletSendCalls", {
+      id: this.#id,
+      walletSendCalls,
+      isOptimistic,
+    });
+  }
+
+  /**
+   * Sends an actions message
+   *
+   * @param actions - The actions to send
+   * @param isOptimistic - Whether to send the message optimistically
+   * @returns Promise that resolves with the message ID after it has been sent
+   */
+  async sendActions(actions: Actions, isOptimistic?: boolean) {
+    return this.#worker.action("conversation.sendActions", {
+      id: this.#id,
+      actions,
+      isOptimistic,
+    });
+  }
+
+  /**
+   * Sends an intent message
+   *
+   * @param intent - The intent to send
+   * @param isOptimistic - Whether to send the message optimistically
+   * @returns Promise that resolves with the message ID after it has been sent
+   */
+  async sendIntent(intent: Intent, isOptimistic?: boolean) {
+    return this.#worker.action("conversation.sendIntent", {
+      id: this.#id,
+      intent,
+      isOptimistic,
+    });
+  }
+
+  /**
+   * Sends an attachment message
+   *
+   * @param attachment - The attachment to send
+   * @param isOptimistic - Whether to send the message optimistically
+   * @returns Promise that resolves with the message ID after it has been sent
+   */
+  async sendAttachment(attachment: Attachment, isOptimistic?: boolean) {
+    return this.#worker.action("conversation.sendAttachment", {
+      id: this.#id,
+      attachment,
+      isOptimistic,
+    });
+  }
+
+  /**
+   * Sends a multi remote attachment message
+   *
+   * @param multiRemoteAttachment - The multi remote attachment to send
+   * @param isOptimistic - Whether to send the message optimistically
+   * @returns Promise that resolves with the message ID after it has been sent
+   */
+  async sendMultiRemoteAttachment(
+    multiRemoteAttachment: MultiRemoteAttachment,
+    isOptimistic?: boolean,
+  ) {
+    return this.#worker.action("conversation.sendMultiRemoteAttachment", {
+      id: this.#id,
+      multiRemoteAttachment,
+      isOptimistic,
+    });
+  }
+
+  /**
+   * Sends a remote attachment message
+   *
+   * @param remoteAttachment - The remote attachment to send
+   * @param isOptimistic - Whether to send the message optimistically
+   * @returns Promise that resolves with the message ID after it has been sent
+   */
+  async sendRemoteAttachment(
+    remoteAttachment: RemoteAttachment,
+    isOptimistic?: boolean,
+  ) {
+    return this.#worker.action("conversation.sendRemoteAttachment", {
+      id: this.#id,
+      remoteAttachment,
+      isOptimistic,
     });
   }
 
@@ -189,13 +351,16 @@ export class Conversation<ContentTypes = unknown> {
    * @param options - Optional filtering and pagination options
    * @returns Promise that resolves with an array of decoded messages
    */
-  async messages(options?: SafeListMessagesOptions) {
-    const messages = await this.#client.sendMessage("conversation.messages", {
+  async messages(options?: ListMessagesOptions) {
+    const messages = await this.#worker.action("conversation.messages", {
       id: this.#id,
       options,
     });
 
-    return messages.map((message) => new DecodedMessage(this.#client, message));
+    return messages.map(
+      (message) =>
+        new DecodedMessage<ContentTypes>(this.#codecRegistry, message),
+    );
   }
 
   /**
@@ -205,9 +370,9 @@ export class Conversation<ContentTypes = unknown> {
    * @returns Promise that resolves with the count of messages
    */
   async countMessages(
-    options?: Omit<SafeListMessagesOptions, "limit" | "direction">,
+    options?: Omit<ListMessagesOptions, "limit" | "direction">,
   ) {
-    const count = await this.#client.sendMessage("conversation.countMessages", {
+    const count = await this.#worker.action("conversation.countMessages", {
       id: this.#id,
       options,
     });
@@ -219,8 +384,8 @@ export class Conversation<ContentTypes = unknown> {
    *
    * @returns Promise that resolves with the current consent state
    */
-  async consentState() {
-    return this.#client.sendMessage("conversation.consentState", {
+  async consentState(): Promise<ConsentState> {
+    return this.#worker.action("conversation.consentState", {
       id: this.#id,
     });
   }
@@ -232,7 +397,7 @@ export class Conversation<ContentTypes = unknown> {
    * @returns Promise that resolves when the update is complete
    */
   async updateConsentState(state: ConsentState) {
-    return this.#client.sendMessage("conversation.updateConsentState", {
+    return this.#worker.action("conversation.updateConsentState", {
       id: this.#id,
       state,
     });
@@ -244,12 +409,9 @@ export class Conversation<ContentTypes = unknown> {
    * @returns Promise that resolves with the current message disappearing settings
    */
   async messageDisappearingSettings() {
-    return this.#client.sendMessage(
-      "conversation.messageDisappearingSettings",
-      {
-        id: this.#id,
-      },
-    );
+    return this.#worker.action("conversation.messageDisappearingSettings", {
+      id: this.#id,
+    });
   }
 
   /**
@@ -260,7 +422,7 @@ export class Conversation<ContentTypes = unknown> {
    * @returns Promise that resolves when the update is complete
    */
   async updateMessageDisappearingSettings(fromNs: bigint, inNs: bigint) {
-    return this.#client.sendMessage(
+    return this.#worker.action(
       "conversation.updateMessageDisappearingSettings",
       {
         id: this.#id,
@@ -276,7 +438,7 @@ export class Conversation<ContentTypes = unknown> {
    * @returns Promise that resolves when the settings are removed
    */
   async removeMessageDisappearingSettings() {
-    return this.#client.sendMessage(
+    return this.#worker.action(
       "conversation.removeMessageDisappearingSettings",
       {
         id: this.#id,
@@ -290,12 +452,9 @@ export class Conversation<ContentTypes = unknown> {
    * @returns Promise that resolves with whether message disappearing is enabled
    */
   async isMessageDisappearingEnabled() {
-    return this.#client.sendMessage(
-      "conversation.isMessageDisappearingEnabled",
-      {
-        id: this.#id,
-      },
-    );
+    return this.#worker.action("conversation.isMessageDisappearingEnabled", {
+      id: this.#id,
+    });
   }
 
   /**
@@ -305,51 +464,51 @@ export class Conversation<ContentTypes = unknown> {
    * @returns Stream instance for new messages
    */
   async stream(
-    options?: StreamOptions<SafeMessage, DecodedMessage<ContentTypes>>,
+    options?: StreamOptions<XmtpDecodedMessage, DecodedMessage<ContentTypes>>,
   ) {
     const stream = async (
-      callback: StreamCallback<SafeMessage>,
+      callback: StreamCallback<XmtpDecodedMessage>,
       onFail: () => void,
     ) => {
-      const streamId = v4();
+      const streamId = uuid();
       if (!options?.disableSync) {
         // sync the conversation
         await this.sync();
       }
       // start the stream
-      await this.#client.sendMessage("conversation.stream", {
+      await this.#worker.action("conversation.stream", {
         groupId: this.#id,
         streamId,
       });
       // handle stream messages
-      return this.#client.handleStreamMessage<
-        SafeMessage,
+      return this.#worker.handleStreamMessage<
+        XmtpDecodedMessage,
         DecodedMessage<ContentTypes>
       >(streamId, callback, {
         ...options,
         onFail,
       });
     };
-    const convertMessage = (value: SafeMessage) => {
-      return new DecodedMessage(this.#client, value);
+    const convertMessage = (value: XmtpDecodedMessage) => {
+      return new DecodedMessage<ContentTypes>(this.#codecRegistry, value);
     };
 
     return createStream(stream, convertMessage, options);
   }
 
   async pausedForVersion() {
-    return this.#client.sendMessage("conversation.pausedForVersion", {
+    return this.#worker.action("conversation.pausedForVersion", {
       id: this.#id,
     });
   }
 
   /**
-   * Retrieves HMAC keys for this conversation
+   * Gets HMAC keys for this conversation
    *
    * @returns Promise that resolves with the HMAC keys
    */
-  async getHmacKeys() {
-    return this.#client.sendMessage("conversation.getHmacKeys", {
+  async hmacKeys() {
+    return this.#worker.action("conversation.hmacKeys", {
       id: this.#id,
     });
   }
@@ -360,7 +519,19 @@ export class Conversation<ContentTypes = unknown> {
    * @returns The debug information for this conversation
    */
   async debugInfo() {
-    return this.#client.sendMessage("conversation.debugInfo", {
+    return this.#worker.action("conversation.debugInfo", {
+      id: this.#id,
+    });
+  }
+
+  /**
+   * Retrieves the last read times for this conversation
+   *
+   * @returns A map keyed by inbox ID with the last read timestamp
+   * (nanoseconds since epoch)
+   */
+  async lastReadTimes() {
+    return this.#worker.action("conversation.lastReadTimes", {
       id: this.#id,
     });
   }