@xmtp/browser-sdk 6.5.0 → 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,
@@ -160,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) {
@@ -176,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,
     });
   }
 
@@ -191,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,
     });
   }
 
@@ -206,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,
     });
   }
 
@@ -234,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,
     });
   }
 
@@ -249,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,
     });
   }
 
@@ -267,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,
     });
   }
 
@@ -285,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,
     });
   }
 
@@ -300,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,
     });
   }
 
@@ -315,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,
     });
   }
 
@@ -330,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,
     });
   }
 
@@ -348,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,11 +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 } 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";
@@ -16,10 +24,12 @@ export class WorkerClient {
   #client: Client;
   #conversations: WorkerConversations;
   #debugInformation: WorkerDebugInformation;
+  #env: XmtpEnv;
   #preferences: WorkerPreferences;
 
-  constructor(client: Client) {
+  constructor(client: Client, env: XmtpEnv) {
     this.#client = client;
+    this.#env = env;
     const conversations = client.conversations();
     this.#conversations = new WorkerConversations(this, conversations);
     this.#debugInformation = new WorkerDebugInformation(client);
@@ -30,8 +40,8 @@ export class WorkerClient {
     identifier: Identifier,
     options?: Omit<ClientOptions, "codecs">,
   ) {
-    const client = await createClient(identifier, options);
-    return new WorkerClient(client);
+    const { client, env } = await createClient(identifier, options);
+    return new WorkerClient(client, env);
   }
 
   get libxmtpVersion() {
@@ -42,6 +52,10 @@ export class WorkerClient {
     return this.#client.appVersion;
   }
 
+  get env() {
+    return this.#env;
+  }
+
   get accountIdentifier() {
     return this.#client.accountIdentifier;
   }
@@ -80,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,
@@ -138,13 +165,17 @@ 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) {
-    return this.#client.findInboxIdByIdentifier(identifier);
+    return this.#client.findInboxIdByIdentity(identifier);
   }
 
   signWithInstallationKey(signatureText: string) {
@@ -185,7 +216,45 @@ export class WorkerClient {
     ) as Promise<Map<string, KeyPackageStatus>>;
   }
 
-  async sendSyncRequest() {
-    return this.#client.sendSyncRequest();
+  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";
@@ -153,19 +154,19 @@ export class WorkerConversation {
   }
 
   async addMembersByIdentifiers(identifiers: Identifier[]) {
-    return this.#group.addMembers(identifiers);
+    return this.#group.addMembersByIdentity(identifiers);
   }
 
   async addMembers(inboxIds: string[]) {
-    return this.#group.addMembersByInboxId(inboxIds);
+    return this.#group.addMembers(inboxIds);
   }
 
   async removeMembersByIdentifiers(identifiers: Identifier[]) {
-    return this.#group.removeMembers(identifiers);
+    return this.#group.removeMembersByIdentity(identifiers);
   }
 
   async removeMembers(inboxIds: string[]) {
-    return this.#group.removeMembersByInboxId(inboxIds);
+    return this.#group.removeMembers(inboxIds);
   }
 
   async addAdmin(inboxId: string) {
@@ -196,70 +197,61 @@ export class WorkerConversation {
     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/constants.ts

@@ -1,6 +1,7 @@
 /**
  * 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
@@ -24,4 +25,8 @@ 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,6 +5,7 @@ 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";
@@ -16,7 +17,12 @@ export type {
   Action,
   Actions,
   ApiStats,
+  ArchiveMetadata,
+  ArchiveOptions,
   Attachment,
+  AvailableArchiveInfo,
+  Backend,
+  BackendBuilder,
   Consent,
   ConversationDebugInfo,
   ConversationListItem,
@@ -50,18 +56,21 @@ export type {
   Reaction,
   ReadReceipt,
   RemoteAttachment,
-  RemoteAttachmentInfo,
   Reply,
   SendMessageOpts,
+  SendOpts,
   SignatureRequestHandle,
   TransactionMetadata,
   TransactionReference,
   UserPreferenceUpdate,
   WalletCall,
   WalletSendCalls,
+  WorkerConfigOptions,
+  WorkerIntervalOverride,
 } from "@xmtp/wasm-bindings";
 export {
   ActionStyle,
+  BackupElementSelectionOption,
   ConsentEntityType,
   ConsentState,
   ContentType,
@@ -81,6 +90,7 @@ export {
   ReactionAction,
   ReactionSchema,
   SortDirection,
+  WorkerKind,
 } from "@xmtp/wasm-bindings";
 export * from "./utils/signer";
 export * from "./utils/errors";