@xmtp/browser-sdk 6.4.1 → 7.0.0-dev.57a7203

package/src/Conversation.ts

@@ -10,6 +10,7 @@ import {
   type RemoteAttachment,
   type Reply,
   type SendMessageOpts,
+  type SendOpts,
   type TransactionReference,
   type WalletSendCalls,
   type DecodedMessage as XmtpDecodedMessage,
@@ -140,6 +141,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
    *
@@ -147,8 +161,10 @@ export class Conversation<ContentTypes = unknown> {
    * @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
+   * @param options.optimistic - Indicates whether this message should be
    * sent optimistically and published later via `publishMessages`
+   * @param options.idempotencyKey - Optional idempotency key; re-sending
+   * identical content with the same key produces the same deduplicated message id
    * @returns Promise that resolves with the message ID after it has been sent
    */
   async send(content: EncodedContent, options?: SendMessageOpts) {
@@ -163,14 +179,14 @@ export class Conversation<ContentTypes = unknown> {
    * Sends a text message
    *
    * @param text - The text to send
-   * @param isOptimistic - Whether to send the message optimistically
+   * @param opts - Send options (optimistic delivery, idempotency key)
    * @returns Promise that resolves with the message ID after it has been sent
    */
-  async sendText(text: string, isOptimistic?: boolean) {
+  async sendText(text: string, opts?: SendOpts) {
     return this.#worker.action("conversation.sendText", {
       id: this.#id,
       text,
-      isOptimistic,
+      opts,
     });
   }
 
@@ -178,14 +194,14 @@ export class Conversation<ContentTypes = unknown> {
    * Sends a markdown message
    *
    * @param markdown - The markdown to send
-   * @param isOptimistic - Whether to send the message optimistically
+   * @param opts - Send options (optimistic delivery, idempotency key)
    * @returns Promise that resolves with the message ID after it has been sent
    */
-  async sendMarkdown(markdown: string, isOptimistic?: boolean) {
+  async sendMarkdown(markdown: string, opts?: SendOpts) {
     return this.#worker.action("conversation.sendMarkdown", {
       id: this.#id,
       markdown,
-      isOptimistic,
+      opts,
     });
   }
 
@@ -193,27 +209,27 @@ export class Conversation<ContentTypes = unknown> {
    * Sends a reaction message
    *
    * @param reaction - The reaction to send
-   * @param isOptimistic - Whether to send the message optimistically
+   * @param opts - Send options (optimistic delivery, idempotency key)
    * @returns Promise that resolves with the message ID after it has been sent
    */
-  async sendReaction(reaction: Reaction, isOptimistic?: boolean) {
+  async sendReaction(reaction: Reaction, opts?: SendOpts) {
     return this.#worker.action("conversation.sendReaction", {
       id: this.#id,
       reaction,
-      isOptimistic,
+      opts,
     });
   }
 
   /**
    * Sends a read receipt message
    *
-   * @param isOptimistic - Whether to send the message optimistically
+   * @param opts - Send options (optimistic delivery, idempotency key)
    * @returns Promise that resolves with the message ID after it has been sent
    */
-  async sendReadReceipt(isOptimistic?: boolean) {
+  async sendReadReceipt(opts?: SendOpts) {
     return this.#worker.action("conversation.sendReadReceipt", {
       id: this.#id,
-      isOptimistic,
+      opts,
     });
   }
 
@@ -221,14 +237,14 @@ export class Conversation<ContentTypes = unknown> {
    * Sends a reply message
    *
    * @param reply - The reply to send
-   * @param isOptimistic - Whether to send the message optimistically
+   * @param opts - Send options (optimistic delivery, idempotency key)
    * @returns Promise that resolves with the message ID after it has been sent
    */
-  async sendReply(reply: Reply, isOptimistic?: boolean) {
+  async sendReply(reply: Reply, opts?: SendOpts) {
     return this.#worker.action("conversation.sendReply", {
       id: this.#id,
       reply,
-      isOptimistic,
+      opts,
     });
   }
 
@@ -236,17 +252,17 @@ export class Conversation<ContentTypes = unknown> {
    * Sends a transaction reference message
    *
    * @param transactionReference - The transaction reference to send
-   * @param isOptimistic - Whether to send the message optimistically
+   * @param opts - Send options (optimistic delivery, idempotency key)
    * @returns Promise that resolves with the message ID after it has been sent
    */
   async sendTransactionReference(
     transactionReference: TransactionReference,
-    isOptimistic?: boolean,
+    opts?: SendOpts,
   ) {
     return this.#worker.action("conversation.sendTransactionReference", {
       id: this.#id,
       transactionReference,
-      isOptimistic,
+      opts,
     });
   }
 
@@ -254,17 +270,14 @@ export class Conversation<ContentTypes = unknown> {
    * Sends a wallet send calls message
    *
    * @param walletSendCalls - The wallet send calls to send
-   * @param isOptimistic - Whether to send the message optimistically
+   * @param opts - Send options (optimistic delivery, idempotency key)
    * @returns Promise that resolves with the message ID after it has been sent
    */
-  async sendWalletSendCalls(
-    walletSendCalls: WalletSendCalls,
-    isOptimistic?: boolean,
-  ) {
+  async sendWalletSendCalls(walletSendCalls: WalletSendCalls, opts?: SendOpts) {
     return this.#worker.action("conversation.sendWalletSendCalls", {
       id: this.#id,
       walletSendCalls,
-      isOptimistic,
+      opts,
     });
   }
 
@@ -272,14 +285,14 @@ export class Conversation<ContentTypes = unknown> {
    * Sends an actions message
    *
    * @param actions - The actions to send
-   * @param isOptimistic - Whether to send the message optimistically
+   * @param opts - Send options (optimistic delivery, idempotency key)
    * @returns Promise that resolves with the message ID after it has been sent
    */
-  async sendActions(actions: Actions, isOptimistic?: boolean) {
+  async sendActions(actions: Actions, opts?: SendOpts) {
     return this.#worker.action("conversation.sendActions", {
       id: this.#id,
       actions,
-      isOptimistic,
+      opts,
     });
   }
 
@@ -287,14 +300,14 @@ export class Conversation<ContentTypes = unknown> {
    * Sends an intent message
    *
    * @param intent - The intent to send
-   * @param isOptimistic - Whether to send the message optimistically
+   * @param opts - Send options (optimistic delivery, idempotency key)
    * @returns Promise that resolves with the message ID after it has been sent
    */
-  async sendIntent(intent: Intent, isOptimistic?: boolean) {
+  async sendIntent(intent: Intent, opts?: SendOpts) {
     return this.#worker.action("conversation.sendIntent", {
       id: this.#id,
       intent,
-      isOptimistic,
+      opts,
     });
   }
 
@@ -302,14 +315,14 @@ export class Conversation<ContentTypes = unknown> {
    * Sends an attachment message
    *
    * @param attachment - The attachment to send
-   * @param isOptimistic - Whether to send the message optimistically
+   * @param opts - Send options (optimistic delivery, idempotency key)
    * @returns Promise that resolves with the message ID after it has been sent
    */
-  async sendAttachment(attachment: Attachment, isOptimistic?: boolean) {
+  async sendAttachment(attachment: Attachment, opts?: SendOpts) {
     return this.#worker.action("conversation.sendAttachment", {
       id: this.#id,
       attachment,
-      isOptimistic,
+      opts,
     });
   }
 
@@ -317,17 +330,17 @@ export class Conversation<ContentTypes = unknown> {
    * Sends a multi remote attachment message
    *
    * @param multiRemoteAttachment - The multi remote attachment to send
-   * @param isOptimistic - Whether to send the message optimistically
+   * @param opts - Send options (optimistic delivery, idempotency key)
    * @returns Promise that resolves with the message ID after it has been sent
    */
   async sendMultiRemoteAttachment(
     multiRemoteAttachment: MultiRemoteAttachment,
-    isOptimistic?: boolean,
+    opts?: SendOpts,
   ) {
     return this.#worker.action("conversation.sendMultiRemoteAttachment", {
       id: this.#id,
       multiRemoteAttachment,
-      isOptimistic,
+      opts,
     });
   }
 
@@ -335,17 +348,17 @@ export class Conversation<ContentTypes = unknown> {
    * Sends a remote attachment message
    *
    * @param remoteAttachment - The remote attachment to send
-   * @param isOptimistic - Whether to send the message optimistically
+   * @param opts - Send options (optimistic delivery, idempotency key)
    * @returns Promise that resolves with the message ID after it has been sent
    */
   async sendRemoteAttachment(
     remoteAttachment: RemoteAttachment,
-    isOptimistic?: boolean,
+    opts?: SendOpts,
   ) {
     return this.#worker.action("conversation.sendRemoteAttachment", {
       id: this.#id,
       remoteAttachment,
-      isOptimistic,
+      opts,
     });
   }
 

package/src/WorkerClient.ts

@@ -1,12 +1,19 @@
 import {
   verifySignedWithPublicKey,
+  type ArchiveMetadata,
   type ArchiveOptions,
+  type AvailableArchiveInfo,
   type Client,
+  type GroupSyncSummary,
   type Identifier,
   type KeyPackageStatus,
   type SignatureRequestHandle,
 } from "@xmtp/wasm-bindings";
-import type { ClientOptions, XmtpEnv } from "@/types/options";
+import type {
+  ClientOptions,
+  VisibilityConfirmationOptions,
+  XmtpEnv,
+} from "@/types/options";
 import { createClient } from "@/utils/createClient";
 import type { SafeSigner } from "@/utils/signer";
 import { WorkerConversations } from "@/WorkerConversations";
@@ -87,6 +94,19 @@ export class WorkerClient {
     >;
   }
 
+  async fetchLatestInboxUpdatesCount(inboxIds: string[]) {
+    const result = (await this.#client.fetchLatestInboxUpdatesCount(
+      true,
+      inboxIds,
+    )) as Map<string, number> | Record<string, number>;
+
+    return result instanceof Map ? Object.fromEntries(result) : result;
+  }
+
+  async fetchOwnInboxUpdatesCount() {
+    return this.#client.fetchOwnInboxUpdatesCount(true);
+  }
+
   async addSignature(
     signatureRequest: SignatureRequestHandle,
     signer: SafeSigner,
@@ -145,9 +165,13 @@ export class WorkerClient {
   async registerIdentity(
     signer: SafeSigner,
     signatureRequest: SignatureRequestHandle,
+    visibilityConfirmationOptions?: VisibilityConfirmationOptions,
   ) {
     await this.addSignature(signatureRequest, signer);
-    await this.#client.registerIdentity(signatureRequest);
+    await this.#client.registerIdentity(
+      signatureRequest,
+      visibilityConfirmationOptions,
+    );
   }
 
   async getInboxIdByIdentifier(identifier: Identifier) {
@@ -195,4 +219,42 @@ export class WorkerClient {
   async sendSyncRequest(options: ArchiveOptions, serverUrl: string) {
     return this.#client.device_sync().sendSyncRequest(options, serverUrl);
   }
+
+  async sendSyncArchive(
+    options: ArchiveOptions,
+    serverUrl: string,
+    pin: string,
+  ) {
+    return this.#client.device_sync().sendSyncArchive(options, serverUrl, pin);
+  }
+
+  async processSyncArchive(archivePin?: string | null) {
+    return this.#client.device_sync().processSyncArchive(archivePin);
+  }
+
+  listAvailableArchives(daysCutoff: number): AvailableArchiveInfo[] {
+    return this.#client.device_sync().listAvailableArchives(BigInt(daysCutoff));
+  }
+
+  async createArchive(
+    opts: ArchiveOptions,
+    key: Uint8Array,
+  ): Promise<Uint8Array> {
+    return this.#client.device_sync().createArchive(opts, key);
+  }
+
+  async importArchive(data: Uint8Array, key: Uint8Array) {
+    return this.#client.device_sync().importArchive(data, key);
+  }
+
+  async archiveMetadata(
+    data: Uint8Array,
+    key: Uint8Array,
+  ): Promise<ArchiveMetadata> {
+    return this.#client.device_sync().archiveMetadata(data, key);
+  }
+
+  async syncAllDeviceSyncGroups(): Promise<GroupSyncSummary> {
+    return this.#client.device_sync().syncAllDeviceSyncGroups();
+  }
 }

package/src/WorkerConversation.ts

@@ -23,6 +23,7 @@ import {
   type RemoteAttachment,
   type Reply,
   type SendMessageOpts,
+  type SendOpts,
   type TransactionReference,
   type WalletSendCalls,
 } from "@xmtp/wasm-bindings";
@@ -188,74 +189,69 @@ 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 });
   }
 
-  async sendText(text: string, isOptimistic?: boolean) {
-    return this.#group.sendText(text, isOptimistic);
+  async sendText(text: string, opts?: SendOpts) {
+    return this.#group.sendText(text, opts);
   }
 
-  async sendMarkdown(markdown: string, isOptimistic?: boolean) {
-    return this.#group.sendMarkdown(markdown, isOptimistic);
+  async sendMarkdown(markdown: string, opts?: SendOpts) {
+    return this.#group.sendMarkdown(markdown, opts);
   }
 
-  async sendReaction(reaction: Reaction, isOptimistic?: boolean) {
-    return this.#group.sendReaction(reaction, isOptimistic);
+  async sendReaction(reaction: Reaction, opts?: SendOpts) {
+    return this.#group.sendReaction(reaction, opts);
   }
 
-  async sendReadReceipt(isOptimistic?: boolean) {
-    return this.#group.sendReadReceipt(isOptimistic);
+  async sendReadReceipt(opts?: SendOpts) {
+    return this.#group.sendReadReceipt(opts);
   }
 
-  async sendReply(reply: Reply, isOptimistic?: boolean) {
-    return this.#group.sendReply(reply, isOptimistic);
+  async sendReply(reply: Reply, opts?: SendOpts) {
+    return this.#group.sendReply(reply, opts);
   }
 
   async sendTransactionReference(
     transactionReference: TransactionReference,
-    isOptimistic?: boolean,
+    opts?: SendOpts,
   ) {
-    return this.#group.sendTransactionReference(
-      transactionReference,
-      isOptimistic,
-    );
+    return this.#group.sendTransactionReference(transactionReference, opts);
   }
 
-  async sendWalletSendCalls(
-    walletSendCalls: WalletSendCalls,
-    isOptimistic?: boolean,
-  ) {
-    return this.#group.sendWalletSendCalls(walletSendCalls, isOptimistic);
+  async sendWalletSendCalls(walletSendCalls: WalletSendCalls, opts?: SendOpts) {
+    return this.#group.sendWalletSendCalls(walletSendCalls, opts);
   }
 
-  async sendActions(actions: Actions, isOptimistic?: boolean) {
-    return this.#group.sendActions(actions, isOptimistic);
+  async sendActions(actions: Actions, opts?: SendOpts) {
+    return this.#group.sendActions(actions, opts);
   }
 
-  async sendIntent(intent: Intent, isOptimistic?: boolean) {
-    return this.#group.sendIntent(intent, isOptimistic);
+  async sendIntent(intent: Intent, opts?: SendOpts) {
+    return this.#group.sendIntent(intent, opts);
   }
 
-  async sendAttachment(attachment: Attachment, isOptimistic?: boolean) {
-    return this.#group.sendAttachment(attachment, isOptimistic);
+  async sendAttachment(attachment: Attachment, opts?: SendOpts) {
+    return this.#group.sendAttachment(attachment, opts);
   }
 
   async sendMultiRemoteAttachment(
     multiRemoteAttachment: MultiRemoteAttachment,
-    isOptimistic?: boolean,
+    opts?: SendOpts,
   ) {
-    return this.#group.sendMultiRemoteAttachment(
-      multiRemoteAttachment,
-      isOptimistic,
-    );
+    return this.#group.sendMultiRemoteAttachment(multiRemoteAttachment, opts);
   }
 
   async sendRemoteAttachment(
     remoteAttachment: RemoteAttachment,
-    isOptimistic?: boolean,
+    opts?: SendOpts,
   ) {
-    return this.#group.sendRemoteAttachment(remoteAttachment, isOptimistic);
+    return this.#group.sendRemoteAttachment(remoteAttachment, opts);
   }
 
   async messages(options?: ListMessagesOptions): Promise<DecodedMessage[]> {

package/src/index.ts

@@ -17,8 +17,10 @@ export type {
   Action,
   Actions,
   ApiStats,
+  ArchiveMetadata,
   ArchiveOptions,
   Attachment,
+  AvailableArchiveInfo,
   Backend,
   BackendBuilder,
   Consent,
@@ -56,12 +58,15 @@ export type {
   RemoteAttachment,
   Reply,
   SendMessageOpts,
+  SendOpts,
   SignatureRequestHandle,
   TransactionMetadata,
   TransactionReference,
   UserPreferenceUpdate,
   WalletCall,
   WalletSendCalls,
+  WorkerConfigOptions,
+  WorkerIntervalOverride,
 } from "@xmtp/wasm-bindings";
 export {
   ActionStyle,
@@ -85,6 +90,7 @@ export {
   ReactionAction,
   ReactionSchema,
   SortDirection,
+  WorkerKind,
 } from "@xmtp/wasm-bindings";
 export * from "./utils/signer";
 export * from "./utils/errors";

package/src/types/actions/client.ts

@@ -1,9 +1,15 @@
 import type {
+  ArchiveMetadata,
   ArchiveOptions,
+  AvailableArchiveInfo,
+  GroupSyncSummary,
   Identifier,
   KeyPackageStatus,
 } from "@xmtp/wasm-bindings";
-import type { ClientOptions } from "@/types/options";
+import type {
+  ClientOptions,
+  VisibilityConfirmationOptions,
+} from "@/types/options";
 import type { SafeSigner } from "@/utils/signer";
 
 export type ClientAction =
@@ -109,6 +115,7 @@ export type ClientAction =
       data: {
         signer: SafeSigner;
         signatureRequestId: string;
+        waitForRegistrationVisible?: VisibilityConfirmationOptions;
       };
     }
   | {
@@ -174,6 +181,20 @@ export type ClientAction =
         identifiers: Identifier[];
       };
     }
+  | {
+      action: "client.fetchLatestInboxUpdatesCount";
+      id: string;
+      result: Record<string, number>;
+      data: {
+        inboxIds: string[];
+      };
+    }
+  | {
+      action: "client.fetchOwnInboxUpdatesCount";
+      id: string;
+      result: number;
+      data: Record<string, never>;
+    }
   | {
       action: "client.getInboxIdByIdentifier";
       id: string;
@@ -225,4 +246,63 @@ export type ClientAction =
         options: ArchiveOptions;
         serverUrl: string;
       };
+    }
+  | {
+      action: "client.sendSyncArchive";
+      id: string;
+      result: undefined;
+      data: {
+        options: ArchiveOptions;
+        serverUrl: string;
+        pin: string;
+      };
+    }
+  | {
+      action: "client.processSyncArchive";
+      id: string;
+      result: undefined;
+      data: {
+        archivePin?: string | null;
+      };
+    }
+  | {
+      action: "client.listAvailableArchives";
+      id: string;
+      result: AvailableArchiveInfo[];
+      data: {
+        daysCutoff: number;
+      };
+    }
+  | {
+      action: "client.createArchive";
+      id: string;
+      result: Uint8Array;
+      data: {
+        opts: ArchiveOptions;
+        key: Uint8Array;
+      };
+    }
+  | {
+      action: "client.importArchive";
+      id: string;
+      result: undefined;
+      data: {
+        data: Uint8Array;
+        key: Uint8Array;
+      };
+    }
+  | {
+      action: "client.archiveMetadata";
+      id: string;
+      result: ArchiveMetadata;
+      data: {
+        data: Uint8Array;
+        key: Uint8Array;
+      };
+    }
+  | {
+      action: "client.syncAllDeviceSyncGroups";
+      id: string;
+      result: GroupSyncSummary;
+      data: undefined;
     };