@xmtp/browser-sdk 5.2.0 → 6.0.0

package/src/utils/errors.ts

@@ -1,5 +1,3 @@
-import type { ContentTypeId } from "@xmtp/content-type-primitives";
-
 export class ClientNotInitializedError extends Error {
   constructor() {
     super(
@@ -16,12 +14,6 @@ export class SignerUnavailableError extends Error {
   }
 }
 
-export class CodecNotFoundError extends Error {
-  constructor(contentType: ContentTypeId) {
-    super(`Codec not found for "${contentType.toString()}" content type`);
-  }
-}
-
 export class InboxReassignError extends Error {
   constructor() {
     super(
@@ -48,27 +40,29 @@ export class StreamNotFoundError extends Error {
   }
 }
 
-export class InvalidGroupMembershipChangeError extends Error {
-  constructor(messageId: string) {
-    super(`Invalid group membership change for message ${messageId}`);
+export class StreamFailedError extends Error {
+  constructor(retryAttempts: number) {
+    const times = `time${retryAttempts !== 1 ? "s" : ""}`;
+    super(`Stream failed, retried ${retryAttempts} ${times}`);
   }
 }
 
-export class MissingContentTypeError extends Error {
+export class StreamInvalidRetryAttemptsError extends Error {
   constructor() {
-    super("Content type is required when sending content other than text");
+    super("Stream retry attempts must be greater than 0");
   }
 }
 
-export class StreamFailedError extends Error {
-  constructor(retryAttempts: number) {
-    const times = `time${retryAttempts !== 1 ? "s" : ""}`;
-    super(`Stream failed, retried ${retryAttempts} ${times}`);
+export class OpfsNotInitializedError extends Error {
+  constructor() {
+    super("OPFS must be initialized before accessing its methods");
   }
 }
 
-export class StreamInvalidRetryAttemptsError extends Error {
+export class OpfsInitializationError extends Error {
   constructor() {
-    super("Stream retry attempts must be greater than 0");
+    super(
+      "Failed to initialize OPFS, ensure that there are no other active XMTP clients or Opfs instances",
+    );
   }
 }

package/src/utils/inboxId.ts

@@ -0,0 +1,46 @@
+import init, {
+  generateInboxId as wasmGenerateInboxId,
+  getInboxIdForIdentifier as wasmGetInboxIdForIdentifier,
+  type Identifier,
+} from "@xmtp/wasm-bindings";
+import { ApiUrls } from "@/constants";
+import type { XmtpEnv } from "@/types/options";
+
+/**
+ * Generates an inbox ID for a given identifier
+ *
+ * @param identifier - The identifier to generate an inbox ID for
+ * @param nonce - Optional nonce to use for generating the inbox ID
+ * @returns Promise that resolves with the generated inbox ID
+ */
+export const generateInboxId = async (
+  identifier: Identifier,
+  nonce?: bigint,
+): Promise<string> => {
+  await init();
+  return wasmGenerateInboxId(identifier, nonce);
+};
+
+/**
+ * Gets the inbox ID for a specific identifier and optional environment
+ *
+ * @param identifier - The identifier to get the inbox ID for
+ * @param env - Optional XMTP environment configuration (default: "dev")
+ * @param gatewayHost - Optional gateway host override
+ * @returns Promise that resolves with the inbox ID for the identifier
+ */
+export const getInboxIdForIdentifier = async (
+  identifier: Identifier,
+  env?: XmtpEnv,
+  gatewayHost?: string,
+): Promise<string | undefined> => {
+  await init();
+  const host = env ? ApiUrls[env] : ApiUrls.dev;
+  const isSecure = host.startsWith("https");
+  return wasmGetInboxIdForIdentifier(
+    host,
+    gatewayHost ?? null,
+    isSecure,
+    identifier,
+  );
+};

package/src/utils/inboxState.ts

@@ -0,0 +1,23 @@
+import init, {
+  inboxStateFromInboxIds as wasmInboxStateFromInboxIds,
+} from "@xmtp/wasm-bindings";
+import { ApiUrls } from "@/constants";
+import type { XmtpEnv } from "@/types/options";
+
+/**
+ * Gets the inbox state for the specified inbox IDs without a client
+ *
+ * @param inboxIds - The inbox IDs to get the state for
+ * @param env - Optional XMTP environment configuration (default: "dev")
+ * @param gatewayHost - Optional gateway host override
+ * @returns The inbox state for the specified inbox IDs
+ */
+export const inboxStateFromInboxIds = async (
+  inboxIds: string[],
+  env?: XmtpEnv,
+  gatewayHost?: string,
+) => {
+  await init();
+  const host = ApiUrls[env ?? "dev"];
+  return wasmInboxStateFromInboxIds(host, gatewayHost ?? null, inboxIds);
+};

package/src/utils/installations.ts

@@ -0,0 +1,95 @@
+import init, {
+  applySignatureRequest,
+  revokeInstallationsSignatureRequest,
+  type Identifier,
+  type SignatureRequestHandle,
+} from "@xmtp/wasm-bindings";
+import { ApiUrls } from "@/constants";
+import type { XmtpEnv } from "@/types/options";
+import type { Signer } from "@/utils/signer";
+
+/**
+ * Creates signature text for revoking installations
+ *
+ * WARNING: This function should be used with caution. It is only provided
+ * for use in special cases where the provided workflows do not meet the
+ * requirements of an application.
+ *
+ * It is highly recommended to use the `revokeInstallations` function instead.
+ *
+ * @param identifier - The identifier to revoke installations for
+ * @param inboxId - The inbox ID to revoke installations for
+ * @param installationIds - The installation IDs to revoke
+ * @param env - Optional XMTP environment configuration (default: "dev")
+ * @param gatewayHost - Optional gateway host override
+ * @returns The signature text and signature request ID
+ */
+export const revokeInstallationsSignatureText = async (
+  identifier: Identifier,
+  inboxId: string,
+  installationIds: Uint8Array[],
+  env?: XmtpEnv,
+  gatewayHost?: string,
+): Promise<{
+  signatureText: string;
+  signatureRequest: SignatureRequestHandle;
+}> => {
+  await init();
+  const host = ApiUrls[env ?? "dev"];
+  const signatureRequest = revokeInstallationsSignatureRequest(
+    host,
+    gatewayHost ?? null,
+    identifier,
+    inboxId,
+    installationIds,
+  );
+  const signatureText = await signatureRequest.signatureText();
+  return { signatureText, signatureRequest };
+};
+
+/**
+ * Revokes installations for a given inbox ID
+ *
+ * @param signer - The signer to use
+ * @param inboxId - The inbox ID to revoke installations for
+ * @param installationIds - The installation IDs to revoke
+ * @param env - Optional XMTP environment configuration (default: "dev")
+ * @param gatewayHost - Optional gateway host override
+ * @returns Promise that resolves when the revoke installations operation is complete
+ */
+export const revokeInstallations = async (
+  signer: Signer,
+  inboxId: string,
+  installationIds: Uint8Array[],
+  env?: XmtpEnv,
+  gatewayHost?: string,
+): Promise<void> => {
+  await init();
+  const identifier = await signer.getIdentifier();
+  const { signatureText, signatureRequest } =
+    await revokeInstallationsSignatureText(
+      identifier,
+      inboxId,
+      installationIds,
+      env,
+      gatewayHost,
+    );
+  const signature = await signer.signMessage(signatureText);
+  const host = ApiUrls[env ?? "dev"];
+
+  switch (signer.type) {
+    case "EOA":
+      await signatureRequest.addEcdsaSignature(signature);
+      break;
+    case "SCW":
+      await signatureRequest.addScwSignature(
+        identifier,
+        signature,
+        signer.getChainId(),
+        signer.getBlockNumber?.(),
+      );
+      break;
+  }
+
+  await applySignatureRequest(host, gatewayHost ?? null, signatureRequest);
+};

package/src/utils/metadata.ts

@@ -0,0 +1,15 @@
+import init, {
+  metadataFieldName as wasmMetadataFieldName,
+  type MetadataField,
+} from "@xmtp/wasm-bindings";
+
+/**
+ * Gets the name of a metadata field
+ *
+ * @param field - The metadata field to get the name for
+ * @returns The name of the metadata field
+ */
+export const metadataFieldName = async (field: MetadataField) => {
+  await init();
+  return wasmMetadataFieldName(field);
+};

package/src/utils/signer.ts

@@ -1,9 +1,9 @@
 import type { Identifier } from "@xmtp/wasm-bindings";
 
-export type SignMessage = (message: string) => Promise<Uint8Array> | Uint8Array;
-export type GetIdentifier = () => Promise<Identifier> | Identifier;
-export type GetChainId = () => bigint;
-export type GetBlockNumber = () => bigint;
+type SignMessage = (message: string) => Promise<Uint8Array> | Uint8Array;
+type GetIdentifier = () => Promise<Identifier> | Identifier;
+type GetChainId = () => bigint;
+type GetBlockNumber = () => bigint;
 
 export type Signer =
   | {

package/src/utils/uuid.ts

@@ -0,0 +1,8 @@
+/**
+ * Generates a unique identifier using crypto.getRandomValues()
+ */
+export const uuid = (): string => {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+};