@dynamic-labs-wallet/forward-mpc-client 0.9.0 → 0.10.0

package/dist/utils-pzTJsc5g.d.cts

@@ -0,0 +1,180 @@
+import { WebSocketError } from '@dynamic-labs-wallet/forward-mpc-shared';
+
+declare const ErrorCode: {
+    readonly CONNECTION_FAILED: "CONNECTION_FAILED";
+    readonly CONNECTION_TIMEOUT: "CONNECTION_TIMEOUT";
+    readonly NOT_CONNECTED: "NOT_CONNECTED";
+    readonly HANDSHAKE_FAILED: "HANDSHAKE_FAILED";
+    readonly HANDSHAKE_INVALID_RESPONSE: "HANDSHAKE_INVALID_RESPONSE";
+    readonly ATTESTATION_FAILED: "ATTESTATION_FAILED";
+    readonly ATTESTATION_PCR_MISMATCH: "ATTESTATION_PCR_MISMATCH";
+    readonly ATTESTATION_CHALLENGE_MISMATCH: "ATTESTATION_CHALLENGE_MISMATCH";
+    readonly ATTESTATION_NONCE_MISMATCH: "ATTESTATION_NONCE_MISMATCH";
+    readonly ATTESTATION_NONCE_MISSING: "ATTESTATION_NONCE_MISSING";
+    readonly ATTESTATION_DOCUMENT_MISSING: "ATTESTATION_DOCUMENT_MISSING";
+    readonly REQUEST_TIMEOUT: "REQUEST_TIMEOUT";
+    readonly SESSION_DISPOSED: "SESSION_DISPOSED";
+    readonly SERVER_ERROR: "SERVER_ERROR";
+    readonly MESSAGE_PARSE_FAILED: "MESSAGE_PARSE_FAILED";
+    readonly SESSION_ESTABLISH_FAILED: "SESSION_ESTABLISH_FAILED";
+    readonly UNSUPPORTED_ALGORITHM: "UNSUPPORTED_ALGORITHM";
+};
+type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
+/**
+ * Focused subset of ErrorCode for attestation verification failures.
+ * Use with `error.code` to distinguish failure modes on SessionAttestationError.
+ */
+declare const AttestationErrorCode: {
+    /** Generic / unrecognised attestation failure */
+    readonly FAILED: "ATTESTATION_FAILED";
+    /** PCR8 hash mismatch — enclave measurement changed */
+    readonly PCR_MISMATCH: "ATTESTATION_PCR_MISMATCH";
+    /** Challenge / ciphertext binding mismatch */
+    readonly CHALLENGE_MISMATCH: "ATTESTATION_CHALLENGE_MISMATCH";
+    /** Nonce value mismatch — possible tampering */
+    readonly NONCE_MISMATCH: "ATTESTATION_NONCE_MISMATCH";
+    /** Nonce field missing from attestation document */
+    readonly NONCE_MISSING: "ATTESTATION_NONCE_MISSING";
+    /** Server did not return an attestation document */
+    readonly DOCUMENT_MISSING: "ATTESTATION_DOCUMENT_MISSING";
+};
+type AttestationErrorCode = (typeof AttestationErrorCode)[keyof typeof AttestationErrorCode];
+declare const ForwardMPCErrorType: {
+    readonly TRANSPORT: "transport";
+    readonly SESSION: "session";
+    readonly CLIENT: "client";
+};
+type ForwardMPCErrorType = (typeof ForwardMPCErrorType)[keyof typeof ForwardMPCErrorType];
+/**
+ * Abstract root for all Forward MPC errors.
+ * `instanceof ForwardMPCError` is true for every error thrown by this library.
+ */
+declare abstract class ForwardMPCError extends Error {
+    readonly code: ErrorCode;
+    readonly type: ForwardMPCErrorType;
+    readonly context?: Record<string, unknown>;
+    constructor(message: string, code: ErrorCode, type: ForwardMPCErrorType, context?: Record<string, unknown>);
+    toJSON(): Record<string, unknown>;
+}
+/** Abstract base for errors originating from the WebSocket / transport layer. */
+declare abstract class TransportError extends ForwardMPCError {
+    constructor(message: string, code: ErrorCode, context?: Record<string, unknown>);
+}
+/** Abstract base for errors originating from the session / crypto / protocol layer. */
+declare abstract class SessionError extends ForwardMPCError {
+    constructor(message: string, code: ErrorCode, context?: Record<string, unknown>);
+}
+/** Abstract base for errors originating from the client / application layer. */
+declare abstract class ClientError extends ForwardMPCError {
+    constructor(message: string, code: ErrorCode, context?: Record<string, unknown>);
+}
+declare class TransportConnectionError extends TransportError {
+    constructor(context?: Record<string, unknown>);
+}
+declare class TransportConnectionTimeoutError extends TransportError {
+    constructor(context?: Record<string, unknown>);
+}
+declare class TransportNotConnectedError extends TransportError {
+    constructor(context?: Record<string, unknown>);
+}
+declare class SessionHandshakeError extends SessionError {
+    constructor(reason: string, context?: Record<string, unknown>);
+}
+declare class SessionHandshakeInvalidResponseError extends SessionError {
+    constructor(context?: Record<string, unknown>);
+}
+/**
+ * Attestation verification failure.
+ * Use `error.code` to distinguish failure reasons (e.g. ATTESTATION_PCR_MISMATCH)
+ * and `error.cause` to inspect the original verifier error.
+ */
+declare class SessionAttestationError extends SessionError {
+    readonly cause?: unknown;
+    constructor(message?: string, code?: ErrorCode, context?: Record<string, unknown>, cause?: unknown);
+}
+declare class SessionRequestTimeoutError extends SessionError {
+    constructor(context?: Record<string, unknown>);
+}
+declare class SessionDisposedError extends SessionError {
+    constructor(context?: Record<string, unknown>);
+}
+declare class SessionServerError extends SessionError {
+    constructor(reason: string, context?: Record<string, unknown>);
+}
+declare class SessionMessageParseError extends SessionError {
+    constructor(context?: Record<string, unknown>);
+}
+/**
+ * The remote server returned an explicit error response.
+ * Carries the full WebSocketError payload so callers can inspect
+ * `serverError.type` and `serverError.details`.
+ */
+declare class SessionRemoteError extends SessionError {
+    readonly serverError: WebSocketError;
+    constructor(serverError: WebSocketError, context?: Record<string, unknown>);
+}
+declare class ClientUnsupportedAlgorithmError extends ClientError {
+    constructor(context?: Record<string, unknown>);
+}
+declare class ClientSessionEstablishFailedError extends ClientError {
+    constructor(context?: Record<string, unknown>);
+}
+
+/**
+ * Error classification result from Forward MPC operations.
+ */
+type ForwardMpcErrorType = 'ATTESTATION_FAILURE' | 'FORWARD_MPC_TIMEOUT' | 'FORWARD_MPC_ERROR';
+/**
+ * Result of classifying a Forward MPC error.
+ */
+interface ForwardMpcErrorClassification {
+    /** The type of error encountered */
+    errorType: ForwardMpcErrorType;
+    /** Error code from ForwardMPCError, if available */
+    errorCode: string | undefined;
+    /** Error message */
+    errorMessage: string;
+    /** Attestation verification errors, if this is an attestation failure */
+    attestationErrors?: unknown[];
+    /** Whether the session was established before the error occurred */
+    sessionEstablished: boolean;
+    /** Whether this error should trigger a fallback to relay-based MPC */
+    shouldFallback: boolean;
+}
+/**
+ * Classifies a Forward MPC error and returns structured data for logging.
+ * Use this to standardize error handling across keygen, signing, and connect operations.
+ *
+ * @param error - The error to classify
+ * @returns Classification result with error details and recommended action
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await forwardMpcClient.sign(...);
+ * } catch (error) {
+ *   const classification = classifyForwardMpcError(error);
+ *   logger.warn(`Forward MPC ${operation} failed`, {
+ *     ...classification,
+ *     chainName,
+ *     environmentId,
+ *   });
+ *   if (classification.shouldFallback) {
+ *     // Fall through to relay-based MPC
+ *   } else {
+ *     throw error;
+ *   }
+ * }
+ * ```
+ */
+declare function classifyForwardMpcError(error: unknown): ForwardMpcErrorClassification;
+/**
+ * Type guard to check if an error is a Forward MPC error that should be handled.
+ */
+declare function isForwardMpcError(error: unknown): error is ForwardMPCError;
+/**
+ * Type guard to check if an error is an attestation failure.
+ */
+declare function isAttestationError(error: unknown): error is SessionAttestationError;
+
+export { AttestationErrorCode as A, ClientError as C, ErrorCode as E, ForwardMPCError as F, SessionAttestationError as S, TransportConnectionError as T, ClientSessionEstablishFailedError as a, ClientUnsupportedAlgorithmError as b, ForwardMPCErrorType as c, type ForwardMpcErrorClassification as d, type ForwardMpcErrorType as e, SessionDisposedError as f, SessionError as g, SessionHandshakeError as h, SessionHandshakeInvalidResponseError as i, SessionMessageParseError as j, SessionRemoteError as k, SessionRequestTimeoutError as l, SessionServerError as m, TransportConnectionTimeoutError as n, TransportError as o, TransportNotConnectedError as p, classifyForwardMpcError as q, isAttestationError as r, isForwardMpcError as s };

package/dist/utils-pzTJsc5g.d.ts

@@ -0,0 +1,180 @@
+import { WebSocketError } from '@dynamic-labs-wallet/forward-mpc-shared';
+
+declare const ErrorCode: {
+    readonly CONNECTION_FAILED: "CONNECTION_FAILED";
+    readonly CONNECTION_TIMEOUT: "CONNECTION_TIMEOUT";
+    readonly NOT_CONNECTED: "NOT_CONNECTED";
+    readonly HANDSHAKE_FAILED: "HANDSHAKE_FAILED";
+    readonly HANDSHAKE_INVALID_RESPONSE: "HANDSHAKE_INVALID_RESPONSE";
+    readonly ATTESTATION_FAILED: "ATTESTATION_FAILED";
+    readonly ATTESTATION_PCR_MISMATCH: "ATTESTATION_PCR_MISMATCH";
+    readonly ATTESTATION_CHALLENGE_MISMATCH: "ATTESTATION_CHALLENGE_MISMATCH";
+    readonly ATTESTATION_NONCE_MISMATCH: "ATTESTATION_NONCE_MISMATCH";
+    readonly ATTESTATION_NONCE_MISSING: "ATTESTATION_NONCE_MISSING";
+    readonly ATTESTATION_DOCUMENT_MISSING: "ATTESTATION_DOCUMENT_MISSING";
+    readonly REQUEST_TIMEOUT: "REQUEST_TIMEOUT";
+    readonly SESSION_DISPOSED: "SESSION_DISPOSED";
+    readonly SERVER_ERROR: "SERVER_ERROR";
+    readonly MESSAGE_PARSE_FAILED: "MESSAGE_PARSE_FAILED";
+    readonly SESSION_ESTABLISH_FAILED: "SESSION_ESTABLISH_FAILED";
+    readonly UNSUPPORTED_ALGORITHM: "UNSUPPORTED_ALGORITHM";
+};
+type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
+/**
+ * Focused subset of ErrorCode for attestation verification failures.
+ * Use with `error.code` to distinguish failure modes on SessionAttestationError.
+ */
+declare const AttestationErrorCode: {
+    /** Generic / unrecognised attestation failure */
+    readonly FAILED: "ATTESTATION_FAILED";
+    /** PCR8 hash mismatch — enclave measurement changed */
+    readonly PCR_MISMATCH: "ATTESTATION_PCR_MISMATCH";
+    /** Challenge / ciphertext binding mismatch */
+    readonly CHALLENGE_MISMATCH: "ATTESTATION_CHALLENGE_MISMATCH";
+    /** Nonce value mismatch — possible tampering */
+    readonly NONCE_MISMATCH: "ATTESTATION_NONCE_MISMATCH";
+    /** Nonce field missing from attestation document */
+    readonly NONCE_MISSING: "ATTESTATION_NONCE_MISSING";
+    /** Server did not return an attestation document */
+    readonly DOCUMENT_MISSING: "ATTESTATION_DOCUMENT_MISSING";
+};
+type AttestationErrorCode = (typeof AttestationErrorCode)[keyof typeof AttestationErrorCode];
+declare const ForwardMPCErrorType: {
+    readonly TRANSPORT: "transport";
+    readonly SESSION: "session";
+    readonly CLIENT: "client";
+};
+type ForwardMPCErrorType = (typeof ForwardMPCErrorType)[keyof typeof ForwardMPCErrorType];
+/**
+ * Abstract root for all Forward MPC errors.
+ * `instanceof ForwardMPCError` is true for every error thrown by this library.
+ */
+declare abstract class ForwardMPCError extends Error {
+    readonly code: ErrorCode;
+    readonly type: ForwardMPCErrorType;
+    readonly context?: Record<string, unknown>;
+    constructor(message: string, code: ErrorCode, type: ForwardMPCErrorType, context?: Record<string, unknown>);
+    toJSON(): Record<string, unknown>;
+}
+/** Abstract base for errors originating from the WebSocket / transport layer. */
+declare abstract class TransportError extends ForwardMPCError {
+    constructor(message: string, code: ErrorCode, context?: Record<string, unknown>);
+}
+/** Abstract base for errors originating from the session / crypto / protocol layer. */
+declare abstract class SessionError extends ForwardMPCError {
+    constructor(message: string, code: ErrorCode, context?: Record<string, unknown>);
+}
+/** Abstract base for errors originating from the client / application layer. */
+declare abstract class ClientError extends ForwardMPCError {
+    constructor(message: string, code: ErrorCode, context?: Record<string, unknown>);
+}
+declare class TransportConnectionError extends TransportError {
+    constructor(context?: Record<string, unknown>);
+}
+declare class TransportConnectionTimeoutError extends TransportError {
+    constructor(context?: Record<string, unknown>);
+}
+declare class TransportNotConnectedError extends TransportError {
+    constructor(context?: Record<string, unknown>);
+}
+declare class SessionHandshakeError extends SessionError {
+    constructor(reason: string, context?: Record<string, unknown>);
+}
+declare class SessionHandshakeInvalidResponseError extends SessionError {
+    constructor(context?: Record<string, unknown>);
+}
+/**
+ * Attestation verification failure.
+ * Use `error.code` to distinguish failure reasons (e.g. ATTESTATION_PCR_MISMATCH)
+ * and `error.cause` to inspect the original verifier error.
+ */
+declare class SessionAttestationError extends SessionError {
+    readonly cause?: unknown;
+    constructor(message?: string, code?: ErrorCode, context?: Record<string, unknown>, cause?: unknown);
+}
+declare class SessionRequestTimeoutError extends SessionError {
+    constructor(context?: Record<string, unknown>);
+}
+declare class SessionDisposedError extends SessionError {
+    constructor(context?: Record<string, unknown>);
+}
+declare class SessionServerError extends SessionError {
+    constructor(reason: string, context?: Record<string, unknown>);
+}
+declare class SessionMessageParseError extends SessionError {
+    constructor(context?: Record<string, unknown>);
+}
+/**
+ * The remote server returned an explicit error response.
+ * Carries the full WebSocketError payload so callers can inspect
+ * `serverError.type` and `serverError.details`.
+ */
+declare class SessionRemoteError extends SessionError {
+    readonly serverError: WebSocketError;
+    constructor(serverError: WebSocketError, context?: Record<string, unknown>);
+}
+declare class ClientUnsupportedAlgorithmError extends ClientError {
+    constructor(context?: Record<string, unknown>);
+}
+declare class ClientSessionEstablishFailedError extends ClientError {
+    constructor(context?: Record<string, unknown>);
+}
+
+/**
+ * Error classification result from Forward MPC operations.
+ */
+type ForwardMpcErrorType = 'ATTESTATION_FAILURE' | 'FORWARD_MPC_TIMEOUT' | 'FORWARD_MPC_ERROR';
+/**
+ * Result of classifying a Forward MPC error.
+ */
+interface ForwardMpcErrorClassification {
+    /** The type of error encountered */
+    errorType: ForwardMpcErrorType;
+    /** Error code from ForwardMPCError, if available */
+    errorCode: string | undefined;
+    /** Error message */
+    errorMessage: string;
+    /** Attestation verification errors, if this is an attestation failure */
+    attestationErrors?: unknown[];
+    /** Whether the session was established before the error occurred */
+    sessionEstablished: boolean;
+    /** Whether this error should trigger a fallback to relay-based MPC */
+    shouldFallback: boolean;
+}
+/**
+ * Classifies a Forward MPC error and returns structured data for logging.
+ * Use this to standardize error handling across keygen, signing, and connect operations.
+ *
+ * @param error - The error to classify
+ * @returns Classification result with error details and recommended action
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await forwardMpcClient.sign(...);
+ * } catch (error) {
+ *   const classification = classifyForwardMpcError(error);
+ *   logger.warn(`Forward MPC ${operation} failed`, {
+ *     ...classification,
+ *     chainName,
+ *     environmentId,
+ *   });
+ *   if (classification.shouldFallback) {
+ *     // Fall through to relay-based MPC
+ *   } else {
+ *     throw error;
+ *   }
+ * }
+ * ```
+ */
+declare function classifyForwardMpcError(error: unknown): ForwardMpcErrorClassification;
+/**
+ * Type guard to check if an error is a Forward MPC error that should be handled.
+ */
+declare function isForwardMpcError(error: unknown): error is ForwardMPCError;
+/**
+ * Type guard to check if an error is an attestation failure.
+ */
+declare function isAttestationError(error: unknown): error is SessionAttestationError;
+
+export { AttestationErrorCode as A, ClientError as C, ErrorCode as E, ForwardMPCError as F, SessionAttestationError as S, TransportConnectionError as T, ClientSessionEstablishFailedError as a, ClientUnsupportedAlgorithmError as b, ForwardMPCErrorType as c, type ForwardMpcErrorClassification as d, type ForwardMpcErrorType as e, SessionDisposedError as f, SessionError as g, SessionHandshakeError as h, SessionHandshakeInvalidResponseError as i, SessionMessageParseError as j, SessionRemoteError as k, SessionRequestTimeoutError as l, SessionServerError as m, TransportConnectionTimeoutError as n, TransportError as o, TransportNotConnectedError as p, classifyForwardMpcError as q, isAttestationError as r, isForwardMpcError as s };

package/dist/utils.cjs

@@ -0,0 +1,119 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/client-v2/errors.ts
+var ErrorCode = {
+  ATTESTATION_FAILED: "ATTESTATION_FAILED",
+  REQUEST_TIMEOUT: "REQUEST_TIMEOUT"};
+var ForwardMPCErrorType = {
+  SESSION: "session"};
+var ForwardMPCError = class extends Error {
+  static {
+    __name(this, "ForwardMPCError");
+  }
+  code;
+  type;
+  context;
+  constructor(message, code, type, context) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.type = type;
+    this.context = context;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      type: this.type,
+      stack: this.stack,
+      context: this.context
+    };
+  }
+};
+var SessionError = class extends ForwardMPCError {
+  static {
+    __name(this, "SessionError");
+  }
+  constructor(message, code, context) {
+    super(message, code, ForwardMPCErrorType.SESSION, context);
+  }
+};
+var SessionAttestationError = class extends SessionError {
+  static {
+    __name(this, "SessionAttestationError");
+  }
+  cause;
+  constructor(message = "Attestation verification failed", code = ErrorCode.ATTESTATION_FAILED, context, cause) {
+    super(message, code, context);
+    if (cause !== void 0) {
+      this.cause = cause;
+    }
+  }
+};
+var SessionRequestTimeoutError = class extends SessionError {
+  static {
+    __name(this, "SessionRequestTimeoutError");
+  }
+  constructor(context) {
+    super("Request timed out waiting for server response", ErrorCode.REQUEST_TIMEOUT, context);
+  }
+};
+
+// src/client-v2/error-classification.ts
+function classifyForwardMpcError(error) {
+  if (error instanceof SessionAttestationError) {
+    return {
+      errorType: "ATTESTATION_FAILURE",
+      errorCode: error.code,
+      errorMessage: error.message,
+      attestationErrors: error.context?.["errors"],
+      sessionEstablished: false,
+      shouldFallback: true
+    };
+  }
+  if (error instanceof SessionRequestTimeoutError) {
+    return {
+      errorType: "FORWARD_MPC_TIMEOUT",
+      errorCode: error.code,
+      errorMessage: error.message,
+      sessionEstablished: true,
+      shouldFallback: false
+    };
+  }
+  if (error instanceof ForwardMPCError) {
+    return {
+      errorType: "FORWARD_MPC_ERROR",
+      errorCode: error.code,
+      errorMessage: error.message,
+      sessionEstablished: true,
+      shouldFallback: false
+    };
+  }
+  return {
+    errorType: "FORWARD_MPC_ERROR",
+    errorCode: void 0,
+    errorMessage: error instanceof Error ? error.message : String(error),
+    sessionEstablished: false,
+    shouldFallback: false
+  };
+}
+__name(classifyForwardMpcError, "classifyForwardMpcError");
+function isForwardMpcError(error) {
+  return error instanceof ForwardMPCError;
+}
+__name(isForwardMpcError, "isForwardMpcError");
+function isAttestationError(error) {
+  return error instanceof SessionAttestationError;
+}
+__name(isAttestationError, "isAttestationError");
+
+exports.classifyForwardMpcError = classifyForwardMpcError;
+exports.isAttestationError = isAttestationError;
+exports.isForwardMpcError = isForwardMpcError;
+//# sourceMappingURL=utils.cjs.map
+//# sourceMappingURL=utils.cjs.map

package/dist/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client-v2/errors.ts","../src/client-v2/error-classification.ts"],"names":["ErrorCode","ATTESTATION_FAILED","REQUEST_TIMEOUT","ForwardMPCErrorType","SESSION","ForwardMPCError","Error","code","type","context","message","name","Object","setPrototypeOf","prototype","toJSON","stack","SessionError","SessionAttestationError","cause","undefined","SessionRequestTimeoutError","classifyForwardMpcError","error","errorType","errorCode","errorMessage","attestationErrors","sessionEstablished","shouldFallback","String","isForwardMpcError","isAttestationError"],"mappings":"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","file":"utils.cjs","sourcesContent":["import { type WebSocketError } from '@dynamic-labs-wallet/forward-mpc-shared';\n\n// ─── Error codes ──────────────────────────────────────────────────────────────\n\nexport const ErrorCode = {\n  // Transport\n  CONNECTION_FAILED: 'CONNECTION_FAILED',\n  CONNECTION_TIMEOUT: 'CONNECTION_TIMEOUT',\n  NOT_CONNECTED: 'NOT_CONNECTED',\n  // Session\n  HANDSHAKE_FAILED: 'HANDSHAKE_FAILED',\n  HANDSHAKE_INVALID_RESPONSE: 'HANDSHAKE_INVALID_RESPONSE',\n  ATTESTATION_FAILED: 'ATTESTATION_FAILED',\n  ATTESTATION_PCR_MISMATCH: 'ATTESTATION_PCR_MISMATCH',\n  ATTESTATION_CHALLENGE_MISMATCH: 'ATTESTATION_CHALLENGE_MISMATCH',\n  ATTESTATION_NONCE_MISMATCH: 'ATTESTATION_NONCE_MISMATCH',\n  ATTESTATION_NONCE_MISSING: 'ATTESTATION_NONCE_MISSING',\n  ATTESTATION_DOCUMENT_MISSING: 'ATTESTATION_DOCUMENT_MISSING',\n  REQUEST_TIMEOUT: 'REQUEST_TIMEOUT',\n  SESSION_DISPOSED: 'SESSION_DISPOSED',\n  SERVER_ERROR: 'SERVER_ERROR',\n  MESSAGE_PARSE_FAILED: 'MESSAGE_PARSE_FAILED',\n  // Client\n  SESSION_ESTABLISH_FAILED: 'SESSION_ESTABLISH_FAILED',\n  UNSUPPORTED_ALGORITHM: 'UNSUPPORTED_ALGORITHM',\n} as const;\n\nexport type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];\n\n/**\n * Focused subset of ErrorCode for attestation verification failures.\n * Use with `error.code` to distinguish failure modes on SessionAttestationError.\n */\nexport const AttestationErrorCode = {\n  /** Generic / unrecognised attestation failure */\n  FAILED: ErrorCode.ATTESTATION_FAILED,\n  /** PCR8 hash mismatch — enclave measurement changed */\n  PCR_MISMATCH: ErrorCode.ATTESTATION_PCR_MISMATCH,\n  /** Challenge / ciphertext binding mismatch */\n  CHALLENGE_MISMATCH: ErrorCode.ATTESTATION_CHALLENGE_MISMATCH,\n  /** Nonce value mismatch — possible tampering */\n  NONCE_MISMATCH: ErrorCode.ATTESTATION_NONCE_MISMATCH,\n  /** Nonce field missing from attestation document */\n  NONCE_MISSING: ErrorCode.ATTESTATION_NONCE_MISSING,\n  /** Server did not return an attestation document */\n  DOCUMENT_MISSING: ErrorCode.ATTESTATION_DOCUMENT_MISSING,\n} as const;\n\nexport type AttestationErrorCode =\n  (typeof AttestationErrorCode)[keyof typeof AttestationErrorCode];\n\n// ─── Error types ──────────────────────────────────────────────────────────────\n\nexport const ForwardMPCErrorType = {\n  TRANSPORT: 'transport',\n  SESSION: 'session',\n  CLIENT: 'client',\n} as const;\n\nexport type ForwardMPCErrorType =\n  (typeof ForwardMPCErrorType)[keyof typeof ForwardMPCErrorType];\n\n// ─── Root base class ──────────────────────────────────────────────────────────\n\n/**\n * Abstract root for all Forward MPC errors.\n * `instanceof ForwardMPCError` is true for every error thrown by this library.\n */\nexport abstract class ForwardMPCError extends Error {\n  public readonly code: ErrorCode;\n  public readonly type: ForwardMPCErrorType;\n  public readonly context?: Record<string, unknown>;\n\n  constructor(\n    message: string,\n    code: ErrorCode,\n    type: ForwardMPCErrorType,\n    context?: Record<string, unknown>\n  ) {\n    super(message);\n    this.name = this.constructor.name;\n    this.code = code;\n    this.type = type;\n    this.context = context;\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n\n  toJSON(): Record<string, unknown> {\n    return {\n      name: this.name,\n      message: this.message,\n      code: this.code,\n      type: this.type,\n      stack: this.stack,\n      context: this.context,\n    };\n  }\n}\n\n// ─── Layer base classes ───────────────────────────────────────────────────────\n\n/** Abstract base for errors originating from the WebSocket / transport layer. */\nexport abstract class TransportError extends ForwardMPCError {\n  constructor(\n    message: string,\n    code: ErrorCode,\n    context?: Record<string, unknown>\n  ) {\n    super(message, code, ForwardMPCErrorType.TRANSPORT, context);\n  }\n}\n\n/** Abstract base for errors originating from the session / crypto / protocol layer. */\nexport abstract class SessionError extends ForwardMPCError {\n  constructor(\n    message: string,\n    code: ErrorCode,\n    context?: Record<string, unknown>\n  ) {\n    super(message, code, ForwardMPCErrorType.SESSION, context);\n  }\n}\n\n/** Abstract base for errors originating from the client / application layer. */\nexport abstract class ClientError extends ForwardMPCError {\n  constructor(\n    message: string,\n    code: ErrorCode,\n    context?: Record<string, unknown>\n  ) {\n    super(message, code, ForwardMPCErrorType.CLIENT, context);\n  }\n}\n\n// ─── Transport errors ─────────────────────────────────────────────────────────\n\nexport class TransportConnectionError extends TransportError {\n  constructor(context?: Record<string, unknown>) {\n    super('WebSocket connection failed', ErrorCode.CONNECTION_FAILED, context);\n  }\n}\n\nexport class TransportConnectionTimeoutError extends TransportError {\n  constructor(context?: Record<string, unknown>) {\n    super(\n      'WebSocket connection timed out',\n      ErrorCode.CONNECTION_TIMEOUT,\n      context\n    );\n  }\n}\n\nexport class TransportNotConnectedError extends TransportError {\n  constructor(context?: Record<string, unknown>) {\n    super('WebSocket is not connected', ErrorCode.NOT_CONNECTED, context);\n  }\n}\n\n// ─── Session errors ───────────────────────────────────────────────────────────\n\nexport class SessionHandshakeError extends SessionError {\n  constructor(reason: string, context?: Record<string, unknown>) {\n    super(\n      `ML-KEM-768 handshake failed: ${reason}`,\n      ErrorCode.HANDSHAKE_FAILED,\n      { reason, ...context }\n    );\n  }\n}\n\nexport class SessionHandshakeInvalidResponseError extends SessionError {\n  constructor(context?: Record<string, unknown>) {\n    super(\n      'Handshake response was invalid or incomplete',\n      ErrorCode.HANDSHAKE_INVALID_RESPONSE,\n      context\n    );\n  }\n}\n\n/**\n * Attestation verification failure.\n * Use `error.code` to distinguish failure reasons (e.g. ATTESTATION_PCR_MISMATCH)\n * and `error.cause` to inspect the original verifier error.\n */\nexport class SessionAttestationError extends SessionError {\n  public readonly cause?: unknown;\n\n  constructor(\n    message: string = 'Attestation verification failed',\n    code: ErrorCode = ErrorCode.ATTESTATION_FAILED,\n    context?: Record<string, unknown>,\n    cause?: unknown\n  ) {\n    super(message, code, context);\n    if (cause !== undefined) {\n      this.cause = cause;\n    }\n  }\n}\n\nexport class SessionRequestTimeoutError extends SessionError {\n  constructor(context?: Record<string, unknown>) {\n    super(\n      'Request timed out waiting for server response',\n      ErrorCode.REQUEST_TIMEOUT,\n      context\n    );\n  }\n}\n\nexport class SessionDisposedError extends SessionError {\n  constructor(context?: Record<string, unknown>) {\n    super('Session has been disposed', ErrorCode.SESSION_DISPOSED, context);\n  }\n}\n\nexport class SessionServerError extends SessionError {\n  constructor(reason: string, context?: Record<string, unknown>) {\n    super(\n      `Server returned an error response: ${reason}`,\n      ErrorCode.SERVER_ERROR,\n      { reason, ...context }\n    );\n  }\n}\n\nexport class SessionMessageParseError extends SessionError {\n  constructor(context?: Record<string, unknown>) {\n    super(\n      'Failed to parse server message',\n      ErrorCode.MESSAGE_PARSE_FAILED,\n      context\n    );\n  }\n}\n\n/**\n * The remote server returned an explicit error response.\n * Carries the full WebSocketError payload so callers can inspect\n * `serverError.type` and `serverError.details`.\n */\nexport class SessionRemoteError extends SessionError {\n  constructor(\n    public readonly serverError: WebSocketError,\n    context?: Record<string, unknown>\n  ) {\n    super(serverError.message, ErrorCode.SERVER_ERROR, context);\n  }\n}\n\n// ─── Client errors ────────────────────────────────────────────────────────────\n\nexport class ClientUnsupportedAlgorithmError extends ClientError {\n  constructor(context?: Record<string, unknown>) {\n    super(\n      'Signing algorithm is not supported',\n      ErrorCode.UNSUPPORTED_ALGORITHM,\n      context\n    );\n  }\n}\n\nexport class ClientSessionEstablishFailedError extends ClientError {\n  constructor(context?: Record<string, unknown>) {\n    super(\n      'Failed to establish session',\n      ErrorCode.SESSION_ESTABLISH_FAILED,\n      context\n    );\n  }\n}\n","import {\n  ForwardMPCError,\n  SessionAttestationError,\n  SessionRequestTimeoutError,\n} from './errors';\n\n/**\n * Error classification result from Forward MPC operations.\n */\nexport type ForwardMpcErrorType =\n  | 'ATTESTATION_FAILURE'\n  | 'FORWARD_MPC_TIMEOUT'\n  | 'FORWARD_MPC_ERROR';\n\n/**\n * Result of classifying a Forward MPC error.\n */\nexport interface ForwardMpcErrorClassification {\n  /** The type of error encountered */\n  errorType: ForwardMpcErrorType;\n  /** Error code from ForwardMPCError, if available */\n  errorCode: string | undefined;\n  /** Error message */\n  errorMessage: string;\n  /** Attestation verification errors, if this is an attestation failure */\n  attestationErrors?: unknown[];\n  /** Whether the session was established before the error occurred */\n  sessionEstablished: boolean;\n  /** Whether this error should trigger a fallback to relay-based MPC */\n  shouldFallback: boolean;\n}\n\n/**\n * Classifies a Forward MPC error and returns structured data for logging.\n * Use this to standardize error handling across keygen, signing, and connect operations.\n *\n * @param error - The error to classify\n * @returns Classification result with error details and recommended action\n *\n * @example\n * ```typescript\n * try {\n *   await forwardMpcClient.sign(...);\n * } catch (error) {\n *   const classification = classifyForwardMpcError(error);\n *   logger.warn(`Forward MPC ${operation} failed`, {\n *     ...classification,\n *     chainName,\n *     environmentId,\n *   });\n *   if (classification.shouldFallback) {\n *     // Fall through to relay-based MPC\n *   } else {\n *     throw error;\n *   }\n * }\n * ```\n */\nexport function classifyForwardMpcError(\n  error: unknown\n): ForwardMpcErrorClassification {\n  if (error instanceof SessionAttestationError) {\n    return {\n      errorType: 'ATTESTATION_FAILURE',\n      errorCode: error.code,\n      errorMessage: error.message,\n      attestationErrors: error.context?.['errors'] as unknown[] | undefined,\n      sessionEstablished: false,\n      shouldFallback: true,\n    };\n  }\n\n  if (error instanceof SessionRequestTimeoutError) {\n    return {\n      errorType: 'FORWARD_MPC_TIMEOUT',\n      errorCode: error.code,\n      errorMessage: error.message,\n      sessionEstablished: true,\n      shouldFallback: false,\n    };\n  }\n\n  if (error instanceof ForwardMPCError) {\n    return {\n      errorType: 'FORWARD_MPC_ERROR',\n      errorCode: error.code,\n      errorMessage: error.message,\n      sessionEstablished: true,\n      shouldFallback: false,\n    };\n  }\n\n  // Unknown error type\n  return {\n    errorType: 'FORWARD_MPC_ERROR',\n    errorCode: undefined,\n    errorMessage: error instanceof Error ? error.message : String(error),\n    sessionEstablished: false,\n    shouldFallback: false,\n  };\n}\n\n/**\n * Type guard to check if an error is a Forward MPC error that should be handled.\n */\nexport function isForwardMpcError(error: unknown): error is ForwardMPCError {\n  return error instanceof ForwardMPCError;\n}\n\n/**\n * Type guard to check if an error is an attestation failure.\n */\nexport function isAttestationError(\n  error: unknown\n): error is SessionAttestationError {\n  return error instanceof SessionAttestationError;\n}\n"]}

package/dist/utils.d.cts

@@ -0,0 +1,2 @@
+export { d as ForwardMpcErrorClassification, e as ForwardMpcErrorType, q as classifyForwardMpcError, r as isAttestationError, s as isForwardMpcError } from './utils-pzTJsc5g.cjs';
+import '@dynamic-labs-wallet/forward-mpc-shared';

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export { d as ForwardMpcErrorClassification, e as ForwardMpcErrorType, q as classifyForwardMpcError, r as isAttestationError, s as isForwardMpcError } from './utils-pzTJsc5g.js';
+import '@dynamic-labs-wallet/forward-mpc-shared';

package/dist/utils.js

@@ -0,0 +1,115 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/client-v2/errors.ts
+var ErrorCode = {
+  ATTESTATION_FAILED: "ATTESTATION_FAILED",
+  REQUEST_TIMEOUT: "REQUEST_TIMEOUT"};
+var ForwardMPCErrorType = {
+  SESSION: "session"};
+var ForwardMPCError = class extends Error {
+  static {
+    __name(this, "ForwardMPCError");
+  }
+  code;
+  type;
+  context;
+  constructor(message, code, type, context) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.type = type;
+    this.context = context;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      type: this.type,
+      stack: this.stack,
+      context: this.context
+    };
+  }
+};
+var SessionError = class extends ForwardMPCError {
+  static {
+    __name(this, "SessionError");
+  }
+  constructor(message, code, context) {
+    super(message, code, ForwardMPCErrorType.SESSION, context);
+  }
+};
+var SessionAttestationError = class extends SessionError {
+  static {
+    __name(this, "SessionAttestationError");
+  }
+  cause;
+  constructor(message = "Attestation verification failed", code = ErrorCode.ATTESTATION_FAILED, context, cause) {
+    super(message, code, context);
+    if (cause !== void 0) {
+      this.cause = cause;
+    }
+  }
+};
+var SessionRequestTimeoutError = class extends SessionError {
+  static {
+    __name(this, "SessionRequestTimeoutError");
+  }
+  constructor(context) {
+    super("Request timed out waiting for server response", ErrorCode.REQUEST_TIMEOUT, context);
+  }
+};
+
+// src/client-v2/error-classification.ts
+function classifyForwardMpcError(error) {
+  if (error instanceof SessionAttestationError) {
+    return {
+      errorType: "ATTESTATION_FAILURE",
+      errorCode: error.code,
+      errorMessage: error.message,
+      attestationErrors: error.context?.["errors"],
+      sessionEstablished: false,
+      shouldFallback: true
+    };
+  }
+  if (error instanceof SessionRequestTimeoutError) {
+    return {
+      errorType: "FORWARD_MPC_TIMEOUT",
+      errorCode: error.code,
+      errorMessage: error.message,
+      sessionEstablished: true,
+      shouldFallback: false
+    };
+  }
+  if (error instanceof ForwardMPCError) {
+    return {
+      errorType: "FORWARD_MPC_ERROR",
+      errorCode: error.code,
+      errorMessage: error.message,
+      sessionEstablished: true,
+      shouldFallback: false
+    };
+  }
+  return {
+    errorType: "FORWARD_MPC_ERROR",
+    errorCode: void 0,
+    errorMessage: error instanceof Error ? error.message : String(error),
+    sessionEstablished: false,
+    shouldFallback: false
+  };
+}
+__name(classifyForwardMpcError, "classifyForwardMpcError");
+function isForwardMpcError(error) {
+  return error instanceof ForwardMPCError;
+}
+__name(isForwardMpcError, "isForwardMpcError");
+function isAttestationError(error) {
+  return error instanceof SessionAttestationError;
+}
+__name(isAttestationError, "isAttestationError");
+
+export { classifyForwardMpcError, isAttestationError, isForwardMpcError };
+//# sourceMappingURL=utils.js.map
+//# sourceMappingURL=utils.js.map