@xmtp/browser-sdk 0.0.1

package/src/WorkerConversation.ts

@@ -0,0 +1,169 @@
+import type {
+  WasmConsentState,
+  WasmEncodedContent,
+  WasmGroup,
+  WasmGroupMember,
+} from "@xmtp/wasm-bindings";
+import {
+  fromSafeListMessagesOptions,
+  type SafeListMessagesOptions,
+} from "@/utils/conversions";
+import type { WorkerClient } from "@/WorkerClient";
+
+export class WorkerConversation {
+  // eslint-disable-next-line no-unused-private-class-members
+  #client: WorkerClient;
+
+  #group: WasmGroup;
+
+  constructor(client: WorkerClient, group: WasmGroup) {
+    this.#client = client;
+    this.#group = group;
+  }
+
+  get id() {
+    return this.#group.id();
+  }
+
+  get name() {
+    return this.#group.group_name();
+  }
+
+  async updateName(name: string) {
+    return this.#group.update_group_name(name);
+  }
+
+  get imageUrl() {
+    return this.#group.group_image_url_square();
+  }
+
+  async updateImageUrl(imageUrl: string) {
+    return this.#group.update_group_image_url_square(imageUrl);
+  }
+
+  get description() {
+    return this.#group.group_description();
+  }
+
+  async updateDescription(description: string) {
+    return this.#group.update_group_description(description);
+  }
+
+  get pinnedFrameUrl() {
+    return this.#group.group_pinned_frame_url();
+  }
+
+  async updatePinnedFrameUrl(pinnedFrameUrl: string) {
+    return this.#group.update_group_pinned_frame_url(pinnedFrameUrl);
+  }
+
+  get isActive() {
+    return this.#group.is_active();
+  }
+
+  get addedByInboxId() {
+    return this.#group.added_by_inbox_id();
+  }
+
+  get createdAtNs() {
+    return this.#group.created_at_ns();
+  }
+
+  get metadata() {
+    const metadata = this.#group.group_metadata();
+    return {
+      creatorInboxId: metadata.creator_inbox_id(),
+      conversationType: metadata.conversation_type(),
+    };
+  }
+
+  async members() {
+    return this.#group.list_members() as Promise<WasmGroupMember[]>;
+  }
+
+  get admins() {
+    return this.#group.admin_list();
+  }
+
+  get superAdmins() {
+    return this.#group.super_admin_list();
+  }
+
+  get permissions() {
+    const permissions = this.#group.group_permissions();
+    return {
+      policyType: permissions.policy_type(),
+      policySet: permissions.policy_set(),
+    };
+  }
+
+  isAdmin(inboxId: string) {
+    return this.#group.is_admin(inboxId);
+  }
+
+  isSuperAdmin(inboxId: string) {
+    return this.#group.is_super_admin(inboxId);
+  }
+
+  async sync() {
+    return this.#group.sync();
+  }
+
+  async addMembers(accountAddresses: string[]) {
+    return this.#group.add_members(accountAddresses);
+  }
+
+  async addMembersByInboxId(inboxIds: string[]) {
+    return this.#group.add_members_by_inbox_id(inboxIds);
+  }
+
+  async removeMembers(accountAddresses: string[]) {
+    return this.#group.remove_members(accountAddresses);
+  }
+
+  async removeMembersByInboxId(inboxIds: string[]) {
+    return this.#group.remove_members_by_inbox_id(inboxIds);
+  }
+
+  async addAdmin(inboxId: string) {
+    return this.#group.add_admin(inboxId);
+  }
+
+  async removeAdmin(inboxId: string) {
+    return this.#group.remove_admin(inboxId);
+  }
+
+  async addSuperAdmin(inboxId: string) {
+    return this.#group.add_super_admin(inboxId);
+  }
+
+  async removeSuperAdmin(inboxId: string) {
+    return this.#group.remove_super_admin(inboxId);
+  }
+
+  async publishMessages() {
+    return this.#group.publish_messages();
+  }
+
+  sendOptimistic(encodedContent: WasmEncodedContent) {
+    return this.#group.send_optimistic(encodedContent);
+  }
+
+  async send(encodedContent: WasmEncodedContent) {
+    return this.#group.send(encodedContent);
+  }
+
+  messages(options?: SafeListMessagesOptions) {
+    return this.#group.find_messages(
+      options ? fromSafeListMessagesOptions(options) : undefined,
+    );
+  }
+
+  get consentState() {
+    return this.#group.consent_state();
+  }
+
+  updateConsentState(state: WasmConsentState) {
+    this.#group.update_consent_state(state);
+  }
+}

package/src/WorkerConversations.ts

@@ -0,0 +1,60 @@
+import type { WasmConversations, WasmGroup } from "@xmtp/wasm-bindings";
+import {
+  fromSafeCreateGroupOptions,
+  fromSafeListConversationsOptions,
+  toSafeMessage,
+  type SafeCreateGroupOptions,
+  type SafeListConversationsOptions,
+} from "@/utils/conversions";
+import type { WorkerClient } from "@/WorkerClient";
+import { WorkerConversation } from "@/WorkerConversation";
+
+export class WorkerConversations {
+  #client: WorkerClient;
+
+  #conversations: WasmConversations;
+
+  constructor(client: WorkerClient, conversations: WasmConversations) {
+    this.#client = client;
+    this.#conversations = conversations;
+  }
+
+  async sync() {
+    return this.#conversations.sync();
+  }
+
+  getConversationById(id: string) {
+    try {
+      const group = this.#conversations.find_group_by_id(id);
+      // findGroupById will throw if group is not found
+      return new WorkerConversation(this.#client, group);
+    } catch {
+      return undefined;
+    }
+  }
+
+  getMessageById(id: string) {
+    try {
+      // findMessageById will throw if message is not found
+      const message = this.#conversations.find_message_by_id(id);
+      return toSafeMessage(message);
+    } catch {
+      return undefined;
+    }
+  }
+
+  async list(options?: SafeListConversationsOptions) {
+    const groups = (await this.#conversations.list(
+      options ? fromSafeListConversationsOptions(options) : undefined,
+    )) as WasmGroup[];
+    return groups.map((group) => new WorkerConversation(this.#client, group));
+  }
+
+  async newGroup(accountAddresses: string[], options?: SafeCreateGroupOptions) {
+    const group = await this.#conversations.create_group(
+      accountAddresses,
+      options ? fromSafeCreateGroupOptions(options) : undefined,
+    );
+    return new WorkerConversation(this.#client, group);
+  }
+}

package/src/constants.ts

@@ -0,0 +1,5 @@
+export const ApiUrls = {
+  local: "http://localhost:5555",
+  dev: "https://dev.xmtp.network",
+  production: "https://production.xmtp.network",
+} as const;

package/src/index.ts

@@ -0,0 +1,9 @@
+export { Client } from "./Client";
+export { Conversations } from "./Conversations";
+export { Conversation } from "./Conversation";
+export * from "./DecodedMessage";
+export { Utils } from "./Utils";
+export { ApiUrls } from "./constants";
+export type * from "./types";
+export * from "./utils/conversions";
+export type * from "@xmtp/wasm-bindings";

package/src/types/clientEvents.ts

@@ -0,0 +1,426 @@
+import type {
+  WasmConsentEntityType,
+  WasmConsentState,
+  WasmSignatureRequestType,
+} from "@xmtp/wasm-bindings";
+import type {
+  ClientOptions,
+  EventsClientMessageData,
+  EventsClientPostMessageData,
+  EventsErrorData,
+  EventsResult,
+  EventsWorkerMessageData,
+  EventsWorkerPostMessageData,
+  SendMessageData,
+} from "@/types";
+import type {
+  SafeConsent,
+  SafeConversation,
+  SafeCreateGroupOptions,
+  SafeEncodedContent,
+  SafeGroupMember,
+  SafeInboxState,
+  SafeListConversationsOptions,
+  SafeListMessagesOptions,
+  SafeMessage,
+} from "@/utils/conversions";
+
+export type ClientEvents =
+  /**
+   * Client actions
+   */
+  | {
+      action: "init";
+      id: string;
+      result: {
+        inboxId: string;
+        installationId: string;
+      };
+      data: {
+        address: string;
+        options?: ClientOptions;
+      };
+    }
+  | {
+      action: "getCreateInboxSignatureText";
+      id: string;
+      result: string | undefined;
+      data: undefined;
+    }
+  | {
+      action: "getAddWalletSignatureText";
+      id: string;
+      result: string | undefined;
+      data: {
+        accountAddress: string;
+      };
+    }
+  | {
+      action: "getRevokeWalletSignatureText";
+      id: string;
+      result: string | undefined;
+      data: {
+        accountAddress: string;
+      };
+    }
+  | {
+      action: "getRevokeInstallationsSignatureText";
+      id: string;
+      result: string | undefined;
+      data: undefined;
+    }
+  | {
+      action: "addSignature";
+      id: string;
+      result: undefined;
+      data: {
+        type: WasmSignatureRequestType;
+        bytes: Uint8Array;
+      };
+    }
+  | {
+      action: "applySignaturesRequests";
+      id: string;
+      result: undefined;
+      data: undefined;
+    }
+  | {
+      action: "registerIdentity";
+      id: string;
+      result: undefined;
+      data: undefined;
+    }
+  | {
+      action: "isRegistered";
+      id: string;
+      result: boolean;
+      data: undefined;
+    }
+  | {
+      action: "canMessage";
+      id: string;
+      result: Map<string, boolean>;
+      data: {
+        accountAddresses: string[];
+      };
+    }
+  | {
+      action: "inboxState";
+      id: string;
+      result: SafeInboxState;
+      data: {
+        refreshFromNetwork: boolean;
+      };
+    }
+  | {
+      action: "getLatestInboxState";
+      id: string;
+      result: SafeInboxState;
+      data: {
+        inboxId: string;
+      };
+    }
+  | {
+      action: "setConsentStates";
+      id: string;
+      result: undefined;
+      data: {
+        records: SafeConsent[];
+      };
+    }
+  | {
+      action: "getConsentState";
+      id: string;
+      result: WasmConsentState;
+      data: {
+        entityType: WasmConsentEntityType;
+        entity: string;
+      };
+    }
+  | {
+      action: "findInboxIdByAddress";
+      id: string;
+      result: string | undefined;
+      data: {
+        address: string;
+      };
+    }
+  /**
+   * Conversations actions
+   */
+  | {
+      action: "getConversationById";
+      id: string;
+      result: SafeConversation | undefined;
+      data: {
+        id: string;
+      };
+    }
+  | {
+      action: "getMessageById";
+      id: string;
+      result: SafeMessage | undefined;
+      data: {
+        id: string;
+      };
+    }
+  | {
+      action: "getConversations";
+      id: string;
+      result: SafeConversation[];
+      data: {
+        options?: SafeListConversationsOptions;
+      };
+    }
+  | {
+      action: "newGroup";
+      id: string;
+      result: SafeConversation;
+      data: {
+        accountAddresses: string[];
+        options?: SafeCreateGroupOptions;
+      };
+    }
+  | {
+      action: "syncConversations";
+      id: string;
+      result: undefined;
+      data: undefined;
+    }
+  /**
+   * Group actions
+   */
+  | {
+      action: "syncGroup";
+      id: string;
+      result: SafeConversation;
+      data: {
+        id: string;
+      };
+    }
+  | {
+      action: "sendGroupMessage";
+      id: string;
+      result: string;
+      data: {
+        id: string;
+        content: SafeEncodedContent;
+      };
+    }
+  | {
+      action: "sendOptimisticGroupMessage";
+      id: string;
+      result: string;
+      data: {
+        id: string;
+        content: SafeEncodedContent;
+      };
+    }
+  | {
+      action: "publishGroupMessages";
+      id: string;
+      result: undefined;
+      data: {
+        id: string;
+      };
+    }
+  | {
+      action: "getGroupMessages";
+      id: string;
+      result: SafeMessage[];
+      data: {
+        id: string;
+        options?: SafeListMessagesOptions;
+      };
+    }
+  | {
+      action: "getGroupMembers";
+      id: string;
+      result: SafeGroupMember[];
+      data: {
+        id: string;
+      };
+    }
+  | {
+      action: "getGroupAdmins";
+      id: string;
+      result: string[];
+      data: {
+        id: string;
+      };
+    }
+  | {
+      action: "getGroupSuperAdmins";
+      id: string;
+      result: string[];
+      data: {
+        id: string;
+      };
+    }
+  | {
+      action: "isGroupAdmin";
+      id: string;
+      result: boolean;
+      data: {
+        id: string;
+        inboxId: string;
+      };
+    }
+  | {
+      action: "isGroupSuperAdmin";
+      id: string;
+      result: boolean;
+      data: {
+        id: string;
+        inboxId: string;
+      };
+    }
+  | {
+      action: "addGroupMembers";
+      id: string;
+      result: undefined;
+      data: {
+        id: string;
+        accountAddresses: string[];
+      };
+    }
+  | {
+      action: "removeGroupMembers";
+      id: string;
+      result: undefined;
+      data: {
+        id: string;
+        accountAddresses: string[];
+      };
+    }
+  | {
+      action: "addGroupMembersByInboxId";
+      id: string;
+      result: undefined;
+      data: {
+        id: string;
+        inboxIds: string[];
+      };
+    }
+  | {
+      action: "removeGroupMembersByInboxId";
+      id: string;
+      result: undefined;
+      data: {
+        id: string;
+        inboxIds: string[];
+      };
+    }
+  | {
+      action: "addGroupAdmin";
+      id: string;
+      result: undefined;
+      data: {
+        id: string;
+        inboxId: string;
+      };
+    }
+  | {
+      action: "removeGroupAdmin";
+      id: string;
+      result: undefined;
+      data: {
+        id: string;
+        inboxId: string;
+      };
+    }
+  | {
+      action: "addGroupSuperAdmin";
+      id: string;
+      result: undefined;
+      data: {
+        id: string;
+        inboxId: string;
+      };
+    }
+  | {
+      action: "removeGroupSuperAdmin";
+      id: string;
+      result: undefined;
+      data: {
+        id: string;
+        inboxId: string;
+      };
+    }
+  | {
+      action: "updateGroupName";
+      id: string;
+      result: undefined;
+      data: {
+        id: string;
+        name: string;
+      };
+    }
+  | {
+      action: "updateGroupDescription";
+      id: string;
+      result: undefined;
+      data: {
+        id: string;
+        description: string;
+      };
+    }
+  | {
+      action: "updateGroupImageUrlSquare";
+      id: string;
+      result: undefined;
+      data: {
+        id: string;
+        imageUrl: string;
+      };
+    }
+  | {
+      action: "updateGroupPinnedFrameUrl";
+      id: string;
+      result: undefined;
+      data: {
+        id: string;
+        pinnedFrameUrl: string;
+      };
+    }
+  | {
+      action: "getGroupConsentState";
+      id: string;
+      result: WasmConsentState;
+      data: {
+        id: string;
+      };
+    }
+  | {
+      action: "updateGroupConsentState";
+      id: string;
+      result: undefined;
+      data: {
+        id: string;
+        state: WasmConsentState;
+      };
+    };
+
+export type ClientEventsActions = ClientEvents["action"];
+
+export type ClientEventsClientMessageData =
+  EventsClientMessageData<ClientEvents>;
+
+export type ClientEventsWorkerMessageData =
+  EventsWorkerMessageData<ClientEvents>;
+
+export type ClientEventsResult<A extends ClientEventsActions> = EventsResult<
+  ClientEvents,
+  A
+>;
+
+export type ClientSendMessageData<A extends ClientEventsActions> =
+  SendMessageData<ClientEvents, A>;
+
+export type ClientEventsWorkerPostMessageData<A extends ClientEventsActions> =
+  EventsWorkerPostMessageData<ClientEvents, A>;
+
+export type ClientEventsClientPostMessageData<A extends ClientEventsActions> =
+  EventsClientPostMessageData<ClientEvents, A>;
+
+export type ClientEventsErrorData = EventsErrorData<ClientEvents>;

package/src/types/index.ts

@@ -0,0 +1,4 @@
+export type * from "./options";
+export type * from "./clientEvents";
+export type * from "./utilsEvents";
+export type * from "./utils";