@xmtp/browser-sdk 0.0.1

package/src/ClientWorkerClass.ts

@@ -0,0 +1,71 @@
+import { v4 } from "uuid";
+import type {
+  ClientEventsActions,
+  ClientEventsErrorData,
+  ClientEventsResult,
+  ClientEventsWorkerMessageData,
+  ClientSendMessageData,
+} from "@/types";
+
+const handleError = (event: ErrorEvent) => {
+  console.error(`Worker error on line ${event.lineno} in "${event.filename}"`);
+  console.error(event.message);
+};
+
+export class ClientWorkerClass {
+  #worker: Worker;
+
+  #enableLogging: boolean;
+
+  #promises = new Map<
+    string,
+    { resolve: (value: any) => void; reject: (reason?: any) => void }
+  >();
+
+  constructor(worker: Worker, enableLogging: boolean) {
+    this.#worker = worker;
+    this.#worker.addEventListener("message", this.handleMessage);
+    this.#worker.addEventListener("error", handleError);
+    this.#enableLogging = enableLogging;
+  }
+
+  sendMessage<A extends ClientEventsActions>(
+    action: A,
+    data: ClientSendMessageData<A>,
+  ) {
+    const promiseId = v4();
+    this.#worker.postMessage({
+      action,
+      id: promiseId,
+      data,
+    });
+    const promise = new Promise<ClientEventsResult<A>>((resolve, reject) => {
+      this.#promises.set(promiseId, { resolve, reject });
+    });
+    return promise;
+  }
+
+  handleMessage = (
+    event: MessageEvent<ClientEventsWorkerMessageData | ClientEventsErrorData>,
+  ) => {
+    const eventData = event.data;
+    if (this.#enableLogging) {
+      console.log("client received event data", eventData);
+    }
+    const promise = this.#promises.get(eventData.id);
+    if (promise) {
+      this.#promises.delete(eventData.id);
+      if ("error" in eventData) {
+        promise.reject(new Error(eventData.error));
+      } else {
+        promise.resolve(eventData.result);
+      }
+    }
+  };
+
+  close() {
+    this.#worker.removeEventListener("message", this.handleMessage);
+    this.#worker.removeEventListener("error", handleError);
+    this.#worker.terminate();
+  }
+}

package/src/Conversation.ts

@@ -0,0 +1,285 @@
+import type { ContentTypeId } from "@xmtp/content-type-primitives";
+import { ContentTypeText } from "@xmtp/content-type-text";
+import type { WasmConsentState } from "@xmtp/wasm-bindings";
+import type { Client } from "@/Client";
+import { DecodedMessage } from "@/DecodedMessage";
+import type {
+  SafeConversation,
+  SafeListMessagesOptions,
+} from "@/utils/conversions";
+import { nsToDate } from "@/utils/date";
+
+export class Conversation {
+  #client: Client;
+
+  #id: string;
+
+  #name?: SafeConversation["name"];
+
+  #imageUrl?: SafeConversation["imageUrl"];
+
+  #description?: SafeConversation["description"];
+
+  #pinnedFrameUrl?: SafeConversation["pinnedFrameUrl"];
+
+  #isActive?: SafeConversation["isActive"];
+
+  #addedByInboxId?: SafeConversation["addedByInboxId"];
+
+  #metadata?: SafeConversation["metadata"];
+
+  #permissions?: SafeConversation["permissions"];
+
+  #createdAtNs?: SafeConversation["createdAtNs"];
+
+  constructor(client: Client, id: string, data?: SafeConversation) {
+    this.#client = client;
+    this.#id = id;
+    this.#syncData(data);
+  }
+
+  #syncData(data?: SafeConversation) {
+    this.#name = data?.name ?? "";
+    this.#imageUrl = data?.imageUrl ?? "";
+    this.#description = data?.description ?? "";
+    this.#pinnedFrameUrl = data?.pinnedFrameUrl ?? "";
+    this.#isActive = data?.isActive ?? undefined;
+    this.#addedByInboxId = data?.addedByInboxId ?? "";
+    this.#metadata = data?.metadata ?? undefined;
+    this.#permissions = data?.permissions ?? undefined;
+    this.#createdAtNs = data?.createdAtNs ?? undefined;
+  }
+
+  get id() {
+    return this.#id;
+  }
+
+  get name() {
+    return this.#name;
+  }
+
+  async updateName(name: string) {
+    await this.#client.sendMessage("updateGroupName", {
+      id: this.#id,
+      name,
+    });
+    this.#name = name;
+  }
+
+  get imageUrl() {
+    return this.#imageUrl;
+  }
+
+  async updateImageUrl(imageUrl: string) {
+    await this.#client.sendMessage("updateGroupImageUrlSquare", {
+      id: this.#id,
+      imageUrl,
+    });
+    this.#imageUrl = imageUrl;
+  }
+
+  get description() {
+    return this.#description;
+  }
+
+  async updateDescription(description: string) {
+    await this.#client.sendMessage("updateGroupDescription", {
+      id: this.#id,
+      description,
+    });
+    this.#description = description;
+  }
+
+  get pinnedFrameUrl() {
+    return this.#pinnedFrameUrl;
+  }
+
+  async updatePinnedFrameUrl(pinnedFrameUrl: string) {
+    await this.#client.sendMessage("updateGroupPinnedFrameUrl", {
+      id: this.#id,
+      pinnedFrameUrl,
+    });
+    this.#pinnedFrameUrl = pinnedFrameUrl;
+  }
+
+  get isActive() {
+    return this.#isActive;
+  }
+
+  get addedByInboxId() {
+    return this.#addedByInboxId;
+  }
+
+  get createdAtNs() {
+    return this.#createdAtNs;
+  }
+
+  get createdAt() {
+    return this.#createdAtNs ? nsToDate(this.#createdAtNs) : undefined;
+  }
+
+  get metadata() {
+    return this.#metadata;
+  }
+
+  async members() {
+    return this.#client.sendMessage("getGroupMembers", {
+      id: this.#id,
+    });
+  }
+
+  async admins() {
+    return this.#client.sendMessage("getGroupAdmins", {
+      id: this.#id,
+    });
+  }
+
+  async superAdmins() {
+    return this.#client.sendMessage("getGroupSuperAdmins", {
+      id: this.#id,
+    });
+  }
+
+  get permissions() {
+    return this.#permissions;
+  }
+
+  async isAdmin(inboxId: string) {
+    const admins = await this.admins();
+    return admins.includes(inboxId);
+  }
+
+  async isSuperAdmin(inboxId: string) {
+    const superAdmins = await this.superAdmins();
+    return superAdmins.includes(inboxId);
+  }
+
+  async sync() {
+    const data = await this.#client.sendMessage("syncGroup", {
+      id: this.#id,
+    });
+    this.#syncData(data);
+  }
+
+  async addMembers(accountAddresses: string[]) {
+    return this.#client.sendMessage("addGroupMembers", {
+      id: this.#id,
+      accountAddresses,
+    });
+  }
+
+  async addMembersByInboxId(inboxIds: string[]) {
+    return this.#client.sendMessage("addGroupMembersByInboxId", {
+      id: this.#id,
+      inboxIds,
+    });
+  }
+
+  async removeMembers(accountAddresses: string[]) {
+    return this.#client.sendMessage("removeGroupMembers", {
+      id: this.#id,
+      accountAddresses,
+    });
+  }
+
+  async removeMembersByInboxId(inboxIds: string[]) {
+    return this.#client.sendMessage("removeGroupMembersByInboxId", {
+      id: this.#id,
+      inboxIds,
+    });
+  }
+
+  async addAdmin(inboxId: string) {
+    return this.#client.sendMessage("addGroupAdmin", {
+      id: this.#id,
+      inboxId,
+    });
+  }
+
+  async removeAdmin(inboxId: string) {
+    return this.#client.sendMessage("removeGroupAdmin", {
+      id: this.#id,
+      inboxId,
+    });
+  }
+
+  async addSuperAdmin(inboxId: string) {
+    return this.#client.sendMessage("addGroupSuperAdmin", {
+      id: this.#id,
+      inboxId,
+    });
+  }
+
+  async removeSuperAdmin(inboxId: string) {
+    return this.#client.sendMessage("removeGroupSuperAdmin", {
+      id: this.#id,
+      inboxId,
+    });
+  }
+
+  async publishMessages() {
+    return this.#client.sendMessage("publishGroupMessages", {
+      id: this.#id,
+    });
+  }
+
+  async sendOptimistic(content: any, contentType?: ContentTypeId) {
+    if (typeof content !== "string" && !contentType) {
+      throw new Error(
+        "Content type is required when sending content other than text",
+      );
+    }
+
+    const safeEncodedContent =
+      typeof content === "string"
+        ? this.#client.encodeContent(content, contentType ?? ContentTypeText)
+        : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          this.#client.encodeContent(content, contentType!);
+
+    return this.#client.sendMessage("sendOptimisticGroupMessage", {
+      id: this.#id,
+      content: safeEncodedContent,
+    });
+  }
+
+  async send(content: any, contentType?: ContentTypeId) {
+    if (typeof content !== "string" && !contentType) {
+      throw new Error(
+        "Content type is required when sending content other than text",
+      );
+    }
+
+    const safeEncodedContent =
+      typeof content === "string"
+        ? this.#client.encodeContent(content, contentType ?? ContentTypeText)
+        : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          this.#client.encodeContent(content, contentType!);
+
+    return this.#client.sendMessage("sendGroupMessage", {
+      id: this.#id,
+      content: safeEncodedContent,
+    });
+  }
+
+  async messages(options?: SafeListMessagesOptions) {
+    const messages = await this.#client.sendMessage("getGroupMessages", {
+      id: this.#id,
+      options,
+    });
+
+    return messages.map((message) => new DecodedMessage(this.#client, message));
+  }
+
+  async consentState() {
+    return this.#client.sendMessage("getGroupConsentState", {
+      id: this.#id,
+    });
+  }
+
+  async updateConsentState(state: WasmConsentState) {
+    return this.#client.sendMessage("updateGroupConsentState", {
+      id: this.#id,
+      state,
+    });
+  }
+}

package/src/Conversations.ts

@@ -0,0 +1,50 @@
+import type { Client } from "@/Client";
+import { Conversation } from "@/Conversation";
+import type {
+  SafeCreateGroupOptions,
+  SafeListConversationsOptions,
+} from "@/utils/conversions";
+
+export class Conversations {
+  #client: Client;
+
+  constructor(client: Client) {
+    this.#client = client;
+  }
+
+  async sync() {
+    return this.#client.sendMessage("syncConversations", undefined);
+  }
+
+  async getConversationById(id: string) {
+    return this.#client.sendMessage("getConversationById", {
+      id,
+    });
+  }
+
+  async getMessageById(id: string) {
+    return this.#client.sendMessage("getMessageById", {
+      id,
+    });
+  }
+
+  async list(options?: SafeListConversationsOptions) {
+    const conversations = await this.#client.sendMessage("getConversations", {
+      options,
+    });
+
+    return conversations.map(
+      (conversation) =>
+        new Conversation(this.#client, conversation.id, conversation),
+    );
+  }
+
+  async newGroup(accountAddresses: string[], options?: SafeCreateGroupOptions) {
+    const conversation = await this.#client.sendMessage("newGroup", {
+      accountAddresses,
+      options,
+    });
+
+    return new Conversation(this.#client, conversation.id, conversation);
+  }
+}

package/src/DecodedMessage.ts

@@ -0,0 +1,71 @@
+import type { ContentTypeId } from "@xmtp/content-type-primitives";
+import { WasmDeliveryStatus, WasmGroupMessageKind } from "@xmtp/wasm-bindings";
+import type { Client } from "@/Client";
+import { fromSafeContentTypeId, type SafeMessage } from "@/utils/conversions";
+
+export type MessageKind = "application" | "membership_change";
+export type MessageDeliveryStatus = "unpublished" | "published" | "failed";
+
+export class DecodedMessage {
+  #client: Client;
+
+  content: any;
+
+  contentType: ContentTypeId;
+
+  conversationId: string;
+
+  deliveryStatus: MessageDeliveryStatus;
+
+  fallback?: string;
+
+  compression?: number;
+
+  id: string;
+
+  kind: MessageKind;
+
+  parameters: Map<string, string>;
+
+  senderInboxId: string;
+
+  sentAtNs: bigint;
+
+  constructor(client: Client, message: SafeMessage) {
+    this.#client = client;
+    this.id = message.id;
+    this.sentAtNs = message.sentAtNs;
+    this.conversationId = message.convoId;
+    this.senderInboxId = message.senderInboxId;
+
+    switch (message.kind) {
+      case WasmGroupMessageKind.Application:
+        this.kind = "application";
+        break;
+      case WasmGroupMessageKind.MembershipChange:
+        this.kind = "membership_change";
+        break;
+      // no default
+    }
+
+    switch (message.deliveryStatus) {
+      case WasmDeliveryStatus.Unpublished:
+        this.deliveryStatus = "unpublished";
+        break;
+      case WasmDeliveryStatus.Published:
+        this.deliveryStatus = "published";
+        break;
+      case WasmDeliveryStatus.Failed:
+        this.deliveryStatus = "failed";
+        break;
+      // no default
+    }
+
+    this.contentType = fromSafeContentTypeId(message.content.type);
+    this.parameters = new Map(Object.entries(message.content.parameters));
+    this.fallback = message.content.fallback;
+    this.compression = message.content.compression;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    this.content = this.#client.decodeContent(message, this.contentType);
+  }
+}

package/src/Utils.ts

@@ -0,0 +1,28 @@
+import type { XmtpEnv } from "@/types/options";
+import { UtilsWorkerClass } from "@/UtilsWorkerClass";
+
+export class Utils extends UtilsWorkerClass {
+  #enableLogging: boolean;
+  constructor(enableLogging?: boolean) {
+    const worker = new Worker(new URL("./workers/utils", import.meta.url), {
+      type: "module",
+    });
+    super(worker, enableLogging ?? false);
+    this.#enableLogging = enableLogging ?? false;
+  }
+
+  async generateInboxId(address: string) {
+    return this.sendMessage("generateInboxId", {
+      address,
+      enableLogging: this.#enableLogging,
+    });
+  }
+
+  async getInboxIdForAddress(address: string, env?: XmtpEnv) {
+    return this.sendMessage("getInboxIdForAddress", {
+      address,
+      env,
+      enableLogging: this.#enableLogging,
+    });
+  }
+}

package/src/UtilsWorkerClass.ts

@@ -0,0 +1,71 @@
+import { v4 } from "uuid";
+import type {
+  UtilsEventsActions,
+  UtilsEventsErrorData,
+  UtilsEventsResult,
+  UtilsEventsWorkerMessageData,
+  UtilsSendMessageData,
+} from "@/types";
+
+const handleError = (event: ErrorEvent) => {
+  console.error(`Worker error on line ${event.lineno} in "${event.filename}"`);
+  console.error(event.message);
+};
+
+export class UtilsWorkerClass {
+  #worker: Worker;
+
+  #enableLogging: boolean;
+
+  #promises = new Map<
+    string,
+    { resolve: (value: any) => void; reject: (reason?: any) => void }
+  >();
+
+  constructor(worker: Worker, enableLogging: boolean) {
+    this.#worker = worker;
+    this.#worker.addEventListener("message", this.handleMessage);
+    this.#worker.addEventListener("error", handleError);
+    this.#enableLogging = enableLogging;
+  }
+
+  sendMessage<A extends UtilsEventsActions>(
+    action: A,
+    data: UtilsSendMessageData<A>,
+  ) {
+    const promiseId = v4();
+    this.#worker.postMessage({
+      action,
+      id: promiseId,
+      data,
+    });
+    const promise = new Promise<UtilsEventsResult<A>>((resolve, reject) => {
+      this.#promises.set(promiseId, { resolve, reject });
+    });
+    return promise;
+  }
+
+  handleMessage = (
+    event: MessageEvent<UtilsEventsWorkerMessageData | UtilsEventsErrorData>,
+  ) => {
+    const eventData = event.data;
+    if (this.#enableLogging) {
+      console.log("utils received event data", eventData);
+    }
+    const promise = this.#promises.get(eventData.id);
+    if (promise) {
+      this.#promises.delete(eventData.id);
+      if ("error" in eventData) {
+        promise.reject(new Error(eventData.error));
+      } else {
+        promise.resolve(eventData.result);
+      }
+    }
+  };
+
+  close() {
+    this.#worker.removeEventListener("message", this.handleMessage);
+    this.#worker.removeEventListener("error", handleError);
+    this.#worker.terminate();
+  }
+}

package/src/WorkerClient.ts

@@ -0,0 +1,124 @@
+import {
+  type WasmClient,
+  type WasmConsentEntityType,
+  type WasmSignatureRequestType,
+} from "@xmtp/wasm-bindings";
+import type { ClientOptions } from "@/types";
+import { fromSafeConsent, type SafeConsent } from "@/utils/conversions";
+import { createClient } from "@/utils/createClient";
+import { WorkerConversations } from "@/WorkerConversations";
+
+export class WorkerClient {
+  #client: WasmClient;
+
+  #conversations: WorkerConversations;
+
+  #accountAddress: string;
+
+  constructor(client: WasmClient) {
+    this.#client = client;
+    this.#accountAddress = client.accountAddress;
+    this.#conversations = new WorkerConversations(this, client.conversations());
+  }
+
+  static async create(
+    accountAddress: string,
+    options?: Omit<ClientOptions, "codecs">,
+  ) {
+    const client = await createClient(accountAddress, options);
+    return new WorkerClient(client);
+  }
+
+  get accountAddress() {
+    return this.#accountAddress;
+  }
+
+  get inboxId() {
+    return this.#client.inboxId;
+  }
+
+  get installationId() {
+    return this.#client.installationId;
+  }
+
+  get isRegistered() {
+    return this.#client.isRegistered;
+  }
+
+  async getCreateInboxSignatureText() {
+    try {
+      return await this.#client.createInboxSignatureText();
+    } catch {
+      return undefined;
+    }
+  }
+
+  async getAddWalletSignatureText(accountAddress: string) {
+    try {
+      return await this.#client.addWalletSignatureText(
+        this.#accountAddress,
+        accountAddress,
+      );
+    } catch {
+      return undefined;
+    }
+  }
+
+  async getRevokeWalletSignatureText(accountAddress: string) {
+    try {
+      return await this.#client.revokeWalletSignatureText(accountAddress);
+    } catch {
+      return undefined;
+    }
+  }
+
+  async getRevokeInstallationsSignatureText() {
+    try {
+      return await this.#client.revokeInstallationsSignatureText();
+    } catch {
+      return undefined;
+    }
+  }
+
+  async addSignature(type: WasmSignatureRequestType, bytes: Uint8Array) {
+    return this.#client.addSignature(type, bytes);
+  }
+
+  async applySignaturesRequests() {
+    return this.#client.applySignatureRequests();
+  }
+
+  async canMessage(accountAddresses: string[]) {
+    return this.#client.canMessage(accountAddresses) as Promise<
+      Map<string, boolean>
+    >;
+  }
+
+  async registerIdentity() {
+    return this.#client.registerIdentity();
+  }
+
+  async findInboxIdByAddress(address: string) {
+    return this.#client.findInboxIdByAddress(address);
+  }
+
+  async inboxState(refreshFromNetwork: boolean) {
+    return this.#client.inboxState(refreshFromNetwork);
+  }
+
+  async getLatestInboxState(inboxId: string) {
+    return this.#client.getLatestInboxState(inboxId);
+  }
+
+  async setConsentStates(records: SafeConsent[]) {
+    return this.#client.setConsentStates(records.map(fromSafeConsent));
+  }
+
+  async getConsentState(entityType: WasmConsentEntityType, entity: string) {
+    return this.#client.getConsentState(entityType, entity);
+  }
+
+  get conversations() {
+    return this.#conversations;
+  }
+}