@metamask/snap-networks-utils 1.0.0 → 2.0.0

package/dist/utils/errors/errors.d.cts

@@ -0,0 +1,37 @@
+import type { Logger } from "../logger/Logger.cjs";
+import type { SnapRpcError } from "./snapRpcError.cjs";
+/**
+ * Sends an error to the snap's tracking transport (e.g. `snap_trackError`).
+ * Whether to invoke this for a given error in a given context is the caller's decision.
+ */
+export type TrackErrorFn = (error: unknown) => Promise<string | undefined>;
+/**
+ * Converts a caught value into an error suitable for Snap RPC responses.
+ */
+export type NormalizeErrorFn = (error: unknown) => SnapRpcError;
+/**
+ * Normalizes an unknown caught value into a Snap RPC error.
+ *
+ * Preserves existing Snap RPC errors; otherwise wraps the value in {@link SnapError}.
+ *
+ * @param error - The caught value.
+ * @returns A Snap RPC error.
+ */
+export declare function normalizeError(error: unknown): SnapRpcError;
+export type LogErrorFn = Logger['error'];
+export type CreateWithCatchAndThrowSnapErrorOptions = {
+    logError: LogErrorFn;
+    trackError: TrackErrorFn;
+    normalizeErrorFn?: NormalizeErrorFn;
+};
+/**
+ * Creates a handler-boundary error wrapper wired with logger, tracking, and optional error normalization.
+ *
+ * @param options - Logger, error-tracking transport, and optional custom normalizer.
+ * @param options.logError - Logger method used to record the normalized error.
+ * @param options.trackError - Snap-specific Sentry transport.
+ * @param options.normalizeErrorFn - Optional error normalizer; defaults to {@link normalizeError}.
+ * @returns A function that catches errors, tracks them, logs, and rethrows as Snap RPC errors.
+ */
+export declare function createWithCatchAndThrowSnapError({ logError, trackError, normalizeErrorFn, }: CreateWithCatchAndThrowSnapErrorOptions): <ResponseT>(fn: () => Promise<ResponseT>, logErrorOverride?: LogErrorFn) => Promise<ResponseT>;
+//# sourceMappingURL=errors.d.cts.map

package/dist/utils/errors/errors.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.cts","sourceRoot":"","sources":["../../../src/utils/errors/errors.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,6BAAyB;AAE/C,OAAO,KAAK,EAAE,YAAY,EAAE,2BAAuB;AAEnD;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,YAAY,CAAC;AAEhE;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CAI3D;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;AAEzC,MAAM,MAAM,uCAAuC,GAAG;IACpD,QAAQ,EAAE,UAAU,CAAC;IACrB,UAAU,EAAE,YAAY,CAAC;IACzB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,gCAAgC,CAAC,EAC/C,QAAQ,EACR,UAAU,EACV,gBAAiC,GAClC,EAAE,uCAAuC,GAAG,CAAC,SAAS,EACrD,EAAE,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,EAC5B,gBAAgB,CAAC,EAAE,UAAU,KAC1B,OAAO,CAAC,SAAS,CAAC,CAWtB"}

package/dist/utils/errors/errors.d.mts

@@ -0,0 +1,37 @@
+import type { Logger } from "../logger/Logger.mjs";
+import type { SnapRpcError } from "./snapRpcError.mjs";
+/**
+ * Sends an error to the snap's tracking transport (e.g. `snap_trackError`).
+ * Whether to invoke this for a given error in a given context is the caller's decision.
+ */
+export type TrackErrorFn = (error: unknown) => Promise<string | undefined>;
+/**
+ * Converts a caught value into an error suitable for Snap RPC responses.
+ */
+export type NormalizeErrorFn = (error: unknown) => SnapRpcError;
+/**
+ * Normalizes an unknown caught value into a Snap RPC error.
+ *
+ * Preserves existing Snap RPC errors; otherwise wraps the value in {@link SnapError}.
+ *
+ * @param error - The caught value.
+ * @returns A Snap RPC error.
+ */
+export declare function normalizeError(error: unknown): SnapRpcError;
+export type LogErrorFn = Logger['error'];
+export type CreateWithCatchAndThrowSnapErrorOptions = {
+    logError: LogErrorFn;
+    trackError: TrackErrorFn;
+    normalizeErrorFn?: NormalizeErrorFn;
+};
+/**
+ * Creates a handler-boundary error wrapper wired with logger, tracking, and optional error normalization.
+ *
+ * @param options - Logger, error-tracking transport, and optional custom normalizer.
+ * @param options.logError - Logger method used to record the normalized error.
+ * @param options.trackError - Snap-specific Sentry transport.
+ * @param options.normalizeErrorFn - Optional error normalizer; defaults to {@link normalizeError}.
+ * @returns A function that catches errors, tracks them, logs, and rethrows as Snap RPC errors.
+ */
+export declare function createWithCatchAndThrowSnapError({ logError, trackError, normalizeErrorFn, }: CreateWithCatchAndThrowSnapErrorOptions): <ResponseT>(fn: () => Promise<ResponseT>, logErrorOverride?: LogErrorFn) => Promise<ResponseT>;
+//# sourceMappingURL=errors.d.mts.map

package/dist/utils/errors/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","sourceRoot":"","sources":["../../../src/utils/errors/errors.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,6BAAyB;AAE/C,OAAO,KAAK,EAAE,YAAY,EAAE,2BAAuB;AAEnD;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,YAAY,CAAC;AAEhE;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CAI3D;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;AAEzC,MAAM,MAAM,uCAAuC,GAAG;IACpD,QAAQ,EAAE,UAAU,CAAC;IACrB,UAAU,EAAE,YAAY,CAAC;IACzB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,gCAAgC,CAAC,EAC/C,QAAQ,EACR,UAAU,EACV,gBAAiC,GAClC,EAAE,uCAAuC,GAAG,CAAC,SAAS,EACrD,EAAE,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,EAC5B,gBAAgB,CAAC,EAAE,UAAU,KAC1B,OAAO,CAAC,SAAS,CAAC,CAWtB"}

package/dist/utils/errors/errors.mjs

@@ -0,0 +1,40 @@
+import { SnapError, getErrorMessage } from "@metamask/snaps-sdk";
+import { isSnapRpcError } from "./snapRpcError.mjs";
+/**
+ * Normalizes an unknown caught value into a Snap RPC error.
+ *
+ * Preserves existing Snap RPC errors; otherwise wraps the value in {@link SnapError}.
+ *
+ * @param error - The caught value.
+ * @returns A Snap RPC error.
+ */
+export function normalizeError(error) {
+    return isSnapRpcError(error)
+        ? error
+        : new SnapError(error instanceof Error ? error : getErrorMessage(error));
+}
+/**
+ * Creates a handler-boundary error wrapper wired with logger, tracking, and optional error normalization.
+ *
+ * @param options - Logger, error-tracking transport, and optional custom normalizer.
+ * @param options.logError - Logger method used to record the normalized error.
+ * @param options.trackError - Snap-specific Sentry transport.
+ * @param options.normalizeErrorFn - Optional error normalizer; defaults to {@link normalizeError}.
+ * @returns A function that catches errors, tracks them, logs, and rethrows as Snap RPC errors.
+ */
+export function createWithCatchAndThrowSnapError({ logError, trackError, normalizeErrorFn = normalizeError, }) {
+    return (fn, logErrorOverride) => withCatchAndThrowSnapErrorHandler(logErrorOverride ?? logError, trackError, normalizeErrorFn, fn);
+}
+async function withCatchAndThrowSnapErrorHandler(logError, trackError, normalizeErrorFn, fn) {
+    try {
+        return await fn();
+    }
+    catch (unknownError) {
+        await trackError(unknownError);
+        const error = normalizeErrorFn(unknownError);
+        logError({ error }, `[SnapError] ${JSON.stringify(error.toJSON(), null, 2)}`);
+        // eslint-disable-next-line @typescript-eslint/only-throw-error -- Snap RPC errors are the handler boundary surface
+        throw error;
+    }
+}
+//# sourceMappingURL=errors.mjs.map

package/dist/utils/errors/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","sourceRoot":"","sources":["../../../src/utils/errors/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,4BAA4B;AAGjE,OAAO,EAAE,cAAc,EAAE,2BAAuB;AAchD;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,OAAO,cAAc,CAAC,KAAK,CAAC;QAC1B,CAAC,CAAC,KAAK;QACP,CAAC,CAAC,IAAI,SAAS,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC;AAC7E,CAAC;AAUD;;;;;;;;GAQG;AACH,MAAM,UAAU,gCAAgC,CAAC,EAC/C,QAAQ,EACR,UAAU,EACV,gBAAgB,GAAG,cAAc,GACO;IAIxC,OAAO,CACL,EAA4B,EAC5B,gBAA6B,EACT,EAAE,CACtB,iCAAiC,CAC/B,gBAAgB,IAAI,QAAQ,EAC5B,UAAU,EACV,gBAAgB,EAChB,EAAE,CACH,CAAC;AACN,CAAC;AAED,KAAK,UAAU,iCAAiC,CAC9C,QAAoB,EACpB,UAAwB,EACxB,gBAAkC,EAClC,EAA4B;IAE5B,IAAI,CAAC;QACH,OAAO,MAAM,EAAE,EAAE,CAAC;IACpB,CAAC;IAAC,OAAO,YAAY,EAAE,CAAC;QACtB,MAAM,UAAU,CAAC,YAAY,CAAC,CAAC;QAE/B,MAAM,KAAK,GAAG,gBAAgB,CAAC,YAAY,CAAC,CAAC;QAE7C,QAAQ,CACN,EAAE,KAAK,EAAE,EACT,eAAe,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CACzD,CAAC;QAEF,mHAAmH;QACnH,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC","sourcesContent":["import { SnapError, getErrorMessage } from '@metamask/snaps-sdk';\n\nimport type { Logger } from '../logger/Logger';\nimport { isSnapRpcError } from './snapRpcError';\nimport type { SnapRpcError } from './snapRpcError';\n\n/**\n * Sends an error to the snap's tracking transport (e.g. `snap_trackError`).\n * Whether to invoke this for a given error in a given context is the caller's decision.\n */\nexport type TrackErrorFn = (error: unknown) => Promise<string | undefined>;\n\n/**\n * Converts a caught value into an error suitable for Snap RPC responses.\n */\nexport type NormalizeErrorFn = (error: unknown) => SnapRpcError;\n\n/**\n * Normalizes an unknown caught value into a Snap RPC error.\n *\n * Preserves existing Snap RPC errors; otherwise wraps the value in {@link SnapError}.\n *\n * @param error - The caught value.\n * @returns A Snap RPC error.\n */\nexport function normalizeError(error: unknown): SnapRpcError {\n  return isSnapRpcError(error)\n    ? error\n    : new SnapError(error instanceof Error ? error : getErrorMessage(error));\n}\n\nexport type LogErrorFn = Logger['error'];\n\nexport type CreateWithCatchAndThrowSnapErrorOptions = {\n  logError: LogErrorFn;\n  trackError: TrackErrorFn;\n  normalizeErrorFn?: NormalizeErrorFn;\n};\n\n/**\n * Creates a handler-boundary error wrapper wired with logger, tracking, and optional error normalization.\n *\n * @param options - Logger, error-tracking transport, and optional custom normalizer.\n * @param options.logError - Logger method used to record the normalized error.\n * @param options.trackError - Snap-specific Sentry transport.\n * @param options.normalizeErrorFn - Optional error normalizer; defaults to {@link normalizeError}.\n * @returns A function that catches errors, tracks them, logs, and rethrows as Snap RPC errors.\n */\nexport function createWithCatchAndThrowSnapError({\n  logError,\n  trackError,\n  normalizeErrorFn = normalizeError,\n}: CreateWithCatchAndThrowSnapErrorOptions): <ResponseT>(\n  fn: () => Promise<ResponseT>,\n  logErrorOverride?: LogErrorFn,\n) => Promise<ResponseT> {\n  return <ResponseT>(\n    fn: () => Promise<ResponseT>,\n    logErrorOverride?: LogErrorFn,\n  ): Promise<ResponseT> =>\n    withCatchAndThrowSnapErrorHandler(\n      logErrorOverride ?? logError,\n      trackError,\n      normalizeErrorFn,\n      fn,\n    );\n}\n\nasync function withCatchAndThrowSnapErrorHandler<ResponseT>(\n  logError: LogErrorFn,\n  trackError: TrackErrorFn,\n  normalizeErrorFn: NormalizeErrorFn,\n  fn: () => Promise<ResponseT>,\n): Promise<ResponseT> {\n  try {\n    return await fn();\n  } catch (unknownError) {\n    await trackError(unknownError);\n\n    const error = normalizeErrorFn(unknownError);\n\n    logError(\n      { error },\n      `[SnapError] ${JSON.stringify(error.toJSON(), null, 2)}`,\n    );\n\n    // eslint-disable-next-line @typescript-eslint/only-throw-error -- Snap RPC errors are the handler boundary surface\n    throw error;\n  }\n}\n"]}

package/dist/utils/errors/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSnapRpcError = exports.stringifyReason = exports.normalizeError = exports.createWithCatchAndThrowSnapError = exports.getSyncFailuresFromSettledResult = exports.formatAccountSyncFailures = exports.SynchronizationError = exports.createTrackError = exports.createSnapErrorHandling = void 0;
+var trackError_1 = require("./trackError.cjs");
+Object.defineProperty(exports, "createSnapErrorHandling", { enumerable: true, get: function () { return trackError_1.createSnapErrorHandling; } });
+Object.defineProperty(exports, "createTrackError", { enumerable: true, get: function () { return trackError_1.createTrackError; } });
+var syncError_1 = require("./syncError.cjs");
+Object.defineProperty(exports, "SynchronizationError", { enumerable: true, get: function () { return syncError_1.SynchronizationError; } });
+Object.defineProperty(exports, "formatAccountSyncFailures", { enumerable: true, get: function () { return syncError_1.formatAccountSyncFailures; } });
+Object.defineProperty(exports, "getSyncFailuresFromSettledResult", { enumerable: true, get: function () { return syncError_1.getSyncFailuresFromSettledResult; } });
+var errors_1 = require("./errors.cjs");
+Object.defineProperty(exports, "createWithCatchAndThrowSnapError", { enumerable: true, get: function () { return errors_1.createWithCatchAndThrowSnapError; } });
+Object.defineProperty(exports, "normalizeError", { enumerable: true, get: function () { return errors_1.normalizeError; } });
+var stringifyReason_1 = require("./stringifyReason.cjs");
+Object.defineProperty(exports, "stringifyReason", { enumerable: true, get: function () { return stringifyReason_1.stringifyReason; } });
+var snapRpcError_1 = require("./snapRpcError.cjs");
+Object.defineProperty(exports, "isSnapRpcError", { enumerable: true, get: function () { return snapRpcError_1.isSnapRpcError; } });
+//# sourceMappingURL=index.cjs.map

package/dist/utils/errors/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../../../src/utils/errors/index.ts"],"names":[],"mappings":";;;AAAA,+CAAyE;AAAhE,qHAAA,uBAAuB,OAAA;AAAE,8GAAA,gBAAgB,OAAA;AAClD,6CAIqB;AAHnB,iHAAA,oBAAoB,OAAA;AACpB,sHAAA,yBAAyB,OAAA;AACzB,6HAAA,gCAAgC,OAAA;AAGlC,uCAA4E;AAAnE,0HAAA,gCAAgC,OAAA;AAAE,wGAAA,cAAc,OAAA;AACzD,yDAAoD;AAA3C,kHAAA,eAAe,OAAA;AACxB,mDAAgD;AAAvC,8GAAA,cAAc,OAAA","sourcesContent":["export { createSnapErrorHandling, createTrackError } from './trackError';\nexport {\n  SynchronizationError,\n  formatAccountSyncFailures,\n  getSyncFailuresFromSettledResult,\n} from './syncError';\nexport type { AccountSyncFailure } from './syncError';\nexport { createWithCatchAndThrowSnapError, normalizeError } from './errors';\nexport { stringifyReason } from './stringifyReason';\nexport { isSnapRpcError } from './snapRpcError';\nexport type {\n  CreateSnapErrorHandlingOptions,\n  CreateTrackErrorOptions,\n  PrepareErrorForTrackingFn,\n  ShouldTrackErrorFn,\n  SnapTrackErrorRequest,\n  TrackErrorCapableProvider,\n} from './trackError';\nexport type {\n  CreateWithCatchAndThrowSnapErrorOptions,\n  LogErrorFn,\n  NormalizeErrorFn,\n  TrackErrorFn,\n} from './errors';\nexport type { SnapRpcError } from './snapRpcError';\n"]}

package/dist/utils/errors/index.d.cts

@@ -0,0 +1,10 @@
+export { createSnapErrorHandling, createTrackError } from "./trackError.cjs";
+export { SynchronizationError, formatAccountSyncFailures, getSyncFailuresFromSettledResult, } from "./syncError.cjs";
+export type { AccountSyncFailure } from "./syncError.cjs";
+export { createWithCatchAndThrowSnapError, normalizeError } from "./errors.cjs";
+export { stringifyReason } from "./stringifyReason.cjs";
+export { isSnapRpcError } from "./snapRpcError.cjs";
+export type { CreateSnapErrorHandlingOptions, CreateTrackErrorOptions, PrepareErrorForTrackingFn, ShouldTrackErrorFn, SnapTrackErrorRequest, TrackErrorCapableProvider, } from "./trackError.cjs";
+export type { CreateWithCatchAndThrowSnapErrorOptions, LogErrorFn, NormalizeErrorFn, TrackErrorFn, } from "./errors.cjs";
+export type { SnapRpcError } from "./snapRpcError.cjs";
+//# sourceMappingURL=index.d.cts.map

package/dist/utils/errors/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../../../src/utils/errors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,yBAAqB;AACzE,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,gCAAgC,GACjC,wBAAoB;AACrB,YAAY,EAAE,kBAAkB,EAAE,wBAAoB;AACtD,OAAO,EAAE,gCAAgC,EAAE,cAAc,EAAE,qBAAiB;AAC5E,OAAO,EAAE,eAAe,EAAE,8BAA0B;AACpD,OAAO,EAAE,cAAc,EAAE,2BAAuB;AAChD,YAAY,EACV,8BAA8B,EAC9B,uBAAuB,EACvB,yBAAyB,EACzB,kBAAkB,EAClB,qBAAqB,EACrB,yBAAyB,GAC1B,yBAAqB;AACtB,YAAY,EACV,uCAAuC,EACvC,UAAU,EACV,gBAAgB,EAChB,YAAY,GACb,qBAAiB;AAClB,YAAY,EAAE,YAAY,EAAE,2BAAuB"}

package/dist/utils/errors/index.d.mts

@@ -0,0 +1,10 @@
+export { createSnapErrorHandling, createTrackError } from "./trackError.mjs";
+export { SynchronizationError, formatAccountSyncFailures, getSyncFailuresFromSettledResult, } from "./syncError.mjs";
+export type { AccountSyncFailure } from "./syncError.mjs";
+export { createWithCatchAndThrowSnapError, normalizeError } from "./errors.mjs";
+export { stringifyReason } from "./stringifyReason.mjs";
+export { isSnapRpcError } from "./snapRpcError.mjs";
+export type { CreateSnapErrorHandlingOptions, CreateTrackErrorOptions, PrepareErrorForTrackingFn, ShouldTrackErrorFn, SnapTrackErrorRequest, TrackErrorCapableProvider, } from "./trackError.mjs";
+export type { CreateWithCatchAndThrowSnapErrorOptions, LogErrorFn, NormalizeErrorFn, TrackErrorFn, } from "./errors.mjs";
+export type { SnapRpcError } from "./snapRpcError.mjs";
+//# sourceMappingURL=index.d.mts.map

package/dist/utils/errors/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/utils/errors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,yBAAqB;AACzE,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,gCAAgC,GACjC,wBAAoB;AACrB,YAAY,EAAE,kBAAkB,EAAE,wBAAoB;AACtD,OAAO,EAAE,gCAAgC,EAAE,cAAc,EAAE,qBAAiB;AAC5E,OAAO,EAAE,eAAe,EAAE,8BAA0B;AACpD,OAAO,EAAE,cAAc,EAAE,2BAAuB;AAChD,YAAY,EACV,8BAA8B,EAC9B,uBAAuB,EACvB,yBAAyB,EACzB,kBAAkB,EAClB,qBAAqB,EACrB,yBAAyB,GAC1B,yBAAqB;AACtB,YAAY,EACV,uCAAuC,EACvC,UAAU,EACV,gBAAgB,EAChB,YAAY,GACb,qBAAiB;AAClB,YAAY,EAAE,YAAY,EAAE,2BAAuB"}

package/dist/utils/errors/index.mjs

@@ -0,0 +1,6 @@
+export { createSnapErrorHandling, createTrackError } from "./trackError.mjs";
+export { SynchronizationError, formatAccountSyncFailures, getSyncFailuresFromSettledResult } from "./syncError.mjs";
+export { createWithCatchAndThrowSnapError, normalizeError } from "./errors.mjs";
+export { stringifyReason } from "./stringifyReason.mjs";
+export { isSnapRpcError } from "./snapRpcError.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/utils/errors/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../src/utils/errors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,yBAAqB;AACzE,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,gCAAgC,EACjC,wBAAoB;AAErB,OAAO,EAAE,gCAAgC,EAAE,cAAc,EAAE,qBAAiB;AAC5E,OAAO,EAAE,eAAe,EAAE,8BAA0B;AACpD,OAAO,EAAE,cAAc,EAAE,2BAAuB","sourcesContent":["export { createSnapErrorHandling, createTrackError } from './trackError';\nexport {\n  SynchronizationError,\n  formatAccountSyncFailures,\n  getSyncFailuresFromSettledResult,\n} from './syncError';\nexport type { AccountSyncFailure } from './syncError';\nexport { createWithCatchAndThrowSnapError, normalizeError } from './errors';\nexport { stringifyReason } from './stringifyReason';\nexport { isSnapRpcError } from './snapRpcError';\nexport type {\n  CreateSnapErrorHandlingOptions,\n  CreateTrackErrorOptions,\n  PrepareErrorForTrackingFn,\n  ShouldTrackErrorFn,\n  SnapTrackErrorRequest,\n  TrackErrorCapableProvider,\n} from './trackError';\nexport type {\n  CreateWithCatchAndThrowSnapErrorOptions,\n  LogErrorFn,\n  NormalizeErrorFn,\n  TrackErrorFn,\n} from './errors';\nexport type { SnapRpcError } from './snapRpcError';\n"]}

package/dist/utils/errors/snapRpcError.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSnapRpcError = isSnapRpcError;
+const snaps_sdk_1 = require("@metamask/snaps-sdk");
+const SNAP_RPC_ERROR_TYPES = [
+    snaps_sdk_1.SnapError,
+    snaps_sdk_1.MethodNotFoundError,
+    snaps_sdk_1.UserRejectedRequestError,
+    snaps_sdk_1.MethodNotSupportedError,
+    snaps_sdk_1.ParseError,
+    snaps_sdk_1.ResourceNotFoundError,
+    snaps_sdk_1.ResourceUnavailableError,
+    snaps_sdk_1.TransactionRejected,
+    snaps_sdk_1.ChainDisconnectedError,
+    snaps_sdk_1.DisconnectedError,
+    snaps_sdk_1.UnauthorizedError,
+    snaps_sdk_1.UnsupportedMethodError,
+    snaps_sdk_1.InternalError,
+    snaps_sdk_1.InvalidInputError,
+    snaps_sdk_1.InvalidParamsError,
+    snaps_sdk_1.InvalidRequestError,
+    snaps_sdk_1.LimitExceededError,
+];
+/**
+ * Determines if the given error is a Snap RPC error.
+ *
+ * @param error - The error instance to be checked.
+ * @returns A boolean indicating whether the error is a Snap RPC error.
+ */
+function isSnapRpcError(error) {
+    return SNAP_RPC_ERROR_TYPES.some((errType) => error instanceof errType);
+}
+//# sourceMappingURL=snapRpcError.cjs.map

package/dist/utils/errors/snapRpcError.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapRpcError.cjs","sourceRoot":"","sources":["../../../src/utils/errors/snapRpcError.ts"],"names":[],"mappings":";;AAkEA,wCAEC;AApED,mDAkB6B;AAsB7B,MAAM,oBAAoB,GAAG;IAC3B,qBAAS;IACT,+BAAmB;IACnB,oCAAwB;IACxB,mCAAuB;IACvB,sBAAU;IACV,iCAAqB;IACrB,oCAAwB;IACxB,+BAAmB;IACnB,kCAAsB;IACtB,6BAAiB;IACjB,6BAAiB;IACjB,kCAAsB;IACtB,yBAAa;IACb,6BAAiB;IACjB,8BAAkB;IAClB,+BAAmB;IACnB,8BAAkB;CACV,CAAC;AAEX;;;;;GAKG;AACH,SAAgB,cAAc,CAAC,KAAsB;IACnD,OAAO,oBAAoB,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,KAAK,YAAY,OAAO,CAAC,CAAC;AAC1E,CAAC","sourcesContent":["import {\n  MethodNotFoundError,\n  ParseError,\n  ResourceNotFoundError,\n  ResourceUnavailableError,\n  ChainDisconnectedError,\n  TransactionRejected,\n  DisconnectedError,\n  InternalError,\n  UnauthorizedError,\n  UnsupportedMethodError,\n  InvalidInputError,\n  InvalidParamsError,\n  InvalidRequestError,\n  LimitExceededError,\n  SnapError,\n  MethodNotSupportedError,\n  UserRejectedRequestError,\n} from '@metamask/snaps-sdk';\n\n/** Union of Snap RPC error instance types (for type narrowing). */\nexport type SnapRpcError =\n  | InstanceType<typeof SnapError>\n  | InstanceType<typeof MethodNotFoundError>\n  | InstanceType<typeof UserRejectedRequestError>\n  | InstanceType<typeof MethodNotSupportedError>\n  | InstanceType<typeof ParseError>\n  | InstanceType<typeof ResourceNotFoundError>\n  | InstanceType<typeof ResourceUnavailableError>\n  | InstanceType<typeof TransactionRejected>\n  | InstanceType<typeof ChainDisconnectedError>\n  | InstanceType<typeof DisconnectedError>\n  | InstanceType<typeof UnauthorizedError>\n  | InstanceType<typeof UnsupportedMethodError>\n  | InstanceType<typeof InternalError>\n  | InstanceType<typeof InvalidInputError>\n  | InstanceType<typeof InvalidParamsError>\n  | InstanceType<typeof InvalidRequestError>\n  | InstanceType<typeof LimitExceededError>;\n\nconst SNAP_RPC_ERROR_TYPES = [\n  SnapError,\n  MethodNotFoundError,\n  UserRejectedRequestError,\n  MethodNotSupportedError,\n  ParseError,\n  ResourceNotFoundError,\n  ResourceUnavailableError,\n  TransactionRejected,\n  ChainDisconnectedError,\n  DisconnectedError,\n  UnauthorizedError,\n  UnsupportedMethodError,\n  InternalError,\n  InvalidInputError,\n  InvalidParamsError,\n  InvalidRequestError,\n  LimitExceededError,\n] as const;\n\n/**\n * Determines if the given error is a Snap RPC error.\n *\n * @param error - The error instance to be checked.\n * @returns A boolean indicating whether the error is a Snap RPC error.\n */\nexport function isSnapRpcError(error: Error | unknown): error is SnapRpcError {\n  return SNAP_RPC_ERROR_TYPES.some((errType) => error instanceof errType);\n}\n"]}

package/dist/utils/errors/snapRpcError.d.cts

@@ -0,0 +1,11 @@
+import { MethodNotFoundError, ParseError, ResourceNotFoundError, ResourceUnavailableError, ChainDisconnectedError, TransactionRejected, DisconnectedError, InternalError, UnauthorizedError, UnsupportedMethodError, InvalidInputError, InvalidParamsError, InvalidRequestError, LimitExceededError, SnapError, MethodNotSupportedError, UserRejectedRequestError } from "@metamask/snaps-sdk";
+/** Union of Snap RPC error instance types (for type narrowing). */
+export type SnapRpcError = InstanceType<typeof SnapError> | InstanceType<typeof MethodNotFoundError> | InstanceType<typeof UserRejectedRequestError> | InstanceType<typeof MethodNotSupportedError> | InstanceType<typeof ParseError> | InstanceType<typeof ResourceNotFoundError> | InstanceType<typeof ResourceUnavailableError> | InstanceType<typeof TransactionRejected> | InstanceType<typeof ChainDisconnectedError> | InstanceType<typeof DisconnectedError> | InstanceType<typeof UnauthorizedError> | InstanceType<typeof UnsupportedMethodError> | InstanceType<typeof InternalError> | InstanceType<typeof InvalidInputError> | InstanceType<typeof InvalidParamsError> | InstanceType<typeof InvalidRequestError> | InstanceType<typeof LimitExceededError>;
+/**
+ * Determines if the given error is a Snap RPC error.
+ *
+ * @param error - The error instance to be checked.
+ * @returns A boolean indicating whether the error is a Snap RPC error.
+ */
+export declare function isSnapRpcError(error: Error | unknown): error is SnapRpcError;
+//# sourceMappingURL=snapRpcError.d.cts.map

package/dist/utils/errors/snapRpcError.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapRpcError.d.cts","sourceRoot":"","sources":["../../../src/utils/errors/snapRpcError.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,UAAU,EACV,qBAAqB,EACrB,wBAAwB,EACxB,sBAAsB,EACtB,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,sBAAsB,EACtB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,SAAS,EACT,uBAAuB,EACvB,wBAAwB,EACzB,4BAA4B;AAE7B,mEAAmE;AACnE,MAAM,MAAM,YAAY,GACpB,YAAY,CAAC,OAAO,SAAS,CAAC,GAC9B,YAAY,CAAC,OAAO,mBAAmB,CAAC,GACxC,YAAY,CAAC,OAAO,wBAAwB,CAAC,GAC7C,YAAY,CAAC,OAAO,uBAAuB,CAAC,GAC5C,YAAY,CAAC,OAAO,UAAU,CAAC,GAC/B,YAAY,CAAC,OAAO,qBAAqB,CAAC,GAC1C,YAAY,CAAC,OAAO,wBAAwB,CAAC,GAC7C,YAAY,CAAC,OAAO,mBAAmB,CAAC,GACxC,YAAY,CAAC,OAAO,sBAAsB,CAAC,GAC3C,YAAY,CAAC,OAAO,iBAAiB,CAAC,GACtC,YAAY,CAAC,OAAO,iBAAiB,CAAC,GACtC,YAAY,CAAC,OAAO,sBAAsB,CAAC,GAC3C,YAAY,CAAC,OAAO,aAAa,CAAC,GAClC,YAAY,CAAC,OAAO,iBAAiB,CAAC,GACtC,YAAY,CAAC,OAAO,kBAAkB,CAAC,GACvC,YAAY,CAAC,OAAO,mBAAmB,CAAC,GACxC,YAAY,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAsB5C;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,GAAG,KAAK,IAAI,YAAY,CAE5E"}

package/dist/utils/errors/snapRpcError.d.mts

@@ -0,0 +1,11 @@
+import { MethodNotFoundError, ParseError, ResourceNotFoundError, ResourceUnavailableError, ChainDisconnectedError, TransactionRejected, DisconnectedError, InternalError, UnauthorizedError, UnsupportedMethodError, InvalidInputError, InvalidParamsError, InvalidRequestError, LimitExceededError, SnapError, MethodNotSupportedError, UserRejectedRequestError } from "@metamask/snaps-sdk";
+/** Union of Snap RPC error instance types (for type narrowing). */
+export type SnapRpcError = InstanceType<typeof SnapError> | InstanceType<typeof MethodNotFoundError> | InstanceType<typeof UserRejectedRequestError> | InstanceType<typeof MethodNotSupportedError> | InstanceType<typeof ParseError> | InstanceType<typeof ResourceNotFoundError> | InstanceType<typeof ResourceUnavailableError> | InstanceType<typeof TransactionRejected> | InstanceType<typeof ChainDisconnectedError> | InstanceType<typeof DisconnectedError> | InstanceType<typeof UnauthorizedError> | InstanceType<typeof UnsupportedMethodError> | InstanceType<typeof InternalError> | InstanceType<typeof InvalidInputError> | InstanceType<typeof InvalidParamsError> | InstanceType<typeof InvalidRequestError> | InstanceType<typeof LimitExceededError>;
+/**
+ * Determines if the given error is a Snap RPC error.
+ *
+ * @param error - The error instance to be checked.
+ * @returns A boolean indicating whether the error is a Snap RPC error.
+ */
+export declare function isSnapRpcError(error: Error | unknown): error is SnapRpcError;
+//# sourceMappingURL=snapRpcError.d.mts.map

package/dist/utils/errors/snapRpcError.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapRpcError.d.mts","sourceRoot":"","sources":["../../../src/utils/errors/snapRpcError.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,UAAU,EACV,qBAAqB,EACrB,wBAAwB,EACxB,sBAAsB,EACtB,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,sBAAsB,EACtB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,SAAS,EACT,uBAAuB,EACvB,wBAAwB,EACzB,4BAA4B;AAE7B,mEAAmE;AACnE,MAAM,MAAM,YAAY,GACpB,YAAY,CAAC,OAAO,SAAS,CAAC,GAC9B,YAAY,CAAC,OAAO,mBAAmB,CAAC,GACxC,YAAY,CAAC,OAAO,wBAAwB,CAAC,GAC7C,YAAY,CAAC,OAAO,uBAAuB,CAAC,GAC5C,YAAY,CAAC,OAAO,UAAU,CAAC,GAC/B,YAAY,CAAC,OAAO,qBAAqB,CAAC,GAC1C,YAAY,CAAC,OAAO,wBAAwB,CAAC,GAC7C,YAAY,CAAC,OAAO,mBAAmB,CAAC,GACxC,YAAY,CAAC,OAAO,sBAAsB,CAAC,GAC3C,YAAY,CAAC,OAAO,iBAAiB,CAAC,GACtC,YAAY,CAAC,OAAO,iBAAiB,CAAC,GACtC,YAAY,CAAC,OAAO,sBAAsB,CAAC,GAC3C,YAAY,CAAC,OAAO,aAAa,CAAC,GAClC,YAAY,CAAC,OAAO,iBAAiB,CAAC,GACtC,YAAY,CAAC,OAAO,kBAAkB,CAAC,GACvC,YAAY,CAAC,OAAO,mBAAmB,CAAC,GACxC,YAAY,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAsB5C;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,GAAG,KAAK,IAAI,YAAY,CAE5E"}

package/dist/utils/errors/snapRpcError.mjs

@@ -0,0 +1,30 @@
+import { MethodNotFoundError, ParseError, ResourceNotFoundError, ResourceUnavailableError, ChainDisconnectedError, TransactionRejected, DisconnectedError, InternalError, UnauthorizedError, UnsupportedMethodError, InvalidInputError, InvalidParamsError, InvalidRequestError, LimitExceededError, SnapError, MethodNotSupportedError, UserRejectedRequestError } from "@metamask/snaps-sdk";
+const SNAP_RPC_ERROR_TYPES = [
+    SnapError,
+    MethodNotFoundError,
+    UserRejectedRequestError,
+    MethodNotSupportedError,
+    ParseError,
+    ResourceNotFoundError,
+    ResourceUnavailableError,
+    TransactionRejected,
+    ChainDisconnectedError,
+    DisconnectedError,
+    UnauthorizedError,
+    UnsupportedMethodError,
+    InternalError,
+    InvalidInputError,
+    InvalidParamsError,
+    InvalidRequestError,
+    LimitExceededError,
+];
+/**
+ * Determines if the given error is a Snap RPC error.
+ *
+ * @param error - The error instance to be checked.
+ * @returns A boolean indicating whether the error is a Snap RPC error.
+ */
+export function isSnapRpcError(error) {
+    return SNAP_RPC_ERROR_TYPES.some((errType) => error instanceof errType);
+}
+//# sourceMappingURL=snapRpcError.mjs.map

package/dist/utils/errors/snapRpcError.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapRpcError.mjs","sourceRoot":"","sources":["../../../src/utils/errors/snapRpcError.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,UAAU,EACV,qBAAqB,EACrB,wBAAwB,EACxB,sBAAsB,EACtB,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,sBAAsB,EACtB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,SAAS,EACT,uBAAuB,EACvB,wBAAwB,EACzB,4BAA4B;AAsB7B,MAAM,oBAAoB,GAAG;IAC3B,SAAS;IACT,mBAAmB;IACnB,wBAAwB;IACxB,uBAAuB;IACvB,UAAU;IACV,qBAAqB;IACrB,wBAAwB;IACxB,mBAAmB;IACnB,sBAAsB;IACtB,iBAAiB;IACjB,iBAAiB;IACjB,sBAAsB;IACtB,aAAa;IACb,iBAAiB;IACjB,kBAAkB;IAClB,mBAAmB;IACnB,kBAAkB;CACV,CAAC;AAEX;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,KAAsB;IACnD,OAAO,oBAAoB,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,KAAK,YAAY,OAAO,CAAC,CAAC;AAC1E,CAAC","sourcesContent":["import {\n  MethodNotFoundError,\n  ParseError,\n  ResourceNotFoundError,\n  ResourceUnavailableError,\n  ChainDisconnectedError,\n  TransactionRejected,\n  DisconnectedError,\n  InternalError,\n  UnauthorizedError,\n  UnsupportedMethodError,\n  InvalidInputError,\n  InvalidParamsError,\n  InvalidRequestError,\n  LimitExceededError,\n  SnapError,\n  MethodNotSupportedError,\n  UserRejectedRequestError,\n} from '@metamask/snaps-sdk';\n\n/** Union of Snap RPC error instance types (for type narrowing). */\nexport type SnapRpcError =\n  | InstanceType<typeof SnapError>\n  | InstanceType<typeof MethodNotFoundError>\n  | InstanceType<typeof UserRejectedRequestError>\n  | InstanceType<typeof MethodNotSupportedError>\n  | InstanceType<typeof ParseError>\n  | InstanceType<typeof ResourceNotFoundError>\n  | InstanceType<typeof ResourceUnavailableError>\n  | InstanceType<typeof TransactionRejected>\n  | InstanceType<typeof ChainDisconnectedError>\n  | InstanceType<typeof DisconnectedError>\n  | InstanceType<typeof UnauthorizedError>\n  | InstanceType<typeof UnsupportedMethodError>\n  | InstanceType<typeof InternalError>\n  | InstanceType<typeof InvalidInputError>\n  | InstanceType<typeof InvalidParamsError>\n  | InstanceType<typeof InvalidRequestError>\n  | InstanceType<typeof LimitExceededError>;\n\nconst SNAP_RPC_ERROR_TYPES = [\n  SnapError,\n  MethodNotFoundError,\n  UserRejectedRequestError,\n  MethodNotSupportedError,\n  ParseError,\n  ResourceNotFoundError,\n  ResourceUnavailableError,\n  TransactionRejected,\n  ChainDisconnectedError,\n  DisconnectedError,\n  UnauthorizedError,\n  UnsupportedMethodError,\n  InternalError,\n  InvalidInputError,\n  InvalidParamsError,\n  InvalidRequestError,\n  LimitExceededError,\n] as const;\n\n/**\n * Determines if the given error is a Snap RPC error.\n *\n * @param error - The error instance to be checked.\n * @returns A boolean indicating whether the error is a Snap RPC error.\n */\nexport function isSnapRpcError(error: Error | unknown): error is SnapRpcError {\n  return SNAP_RPC_ERROR_TYPES.some((errType) => error instanceof errType);\n}\n"]}

package/dist/utils/errors/stringifyReason.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyReason = stringifyReason;
+/**
+ * Stringifies a rejection reason without ever throwing: `String(reason)`
+ * throws when the reason has a hostile `toString`/`Symbol.toPrimitive`. If the
+ * reason is an error with a `cause`, the cause is appended, so the wrapped
+ * failure (e.g. the underlying network error) is part of the reported reason.
+ *
+ * Intended for building human-readable failure reasons (e.g. for
+ * `AccountSyncFailure.reason`), where wrapper errors would otherwise hide the
+ * original failure behind a generic message.
+ *
+ * @param reason - The rejection reason to stringify.
+ * @returns The reason as a string, or a placeholder when stringification fails.
+ */
+function stringifyReason(reason) {
+    try {
+        if (!(reason instanceof Error)) {
+            return String(reason);
+        }
+        const message = String(reason);
+        const { cause } = reason;
+        if (cause === null || cause === undefined) {
+            return message;
+        }
+        // Deliberately permissive: any cause detail is worth reporting, and a
+        // pathological value still ends up as the placeholder via the outer catch.
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        return `${message} (${String(cause)})`;
+    }
+    catch {
+        return 'Unknown error';
+    }
+}
+//# sourceMappingURL=stringifyReason.cjs.map

package/dist/utils/errors/stringifyReason.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringifyReason.cjs","sourceRoot":"","sources":["../../../src/utils/errors/stringifyReason.ts"],"names":[],"mappings":";;AAaA,0CAoBC;AAjCD;;;;;;;;;;;;GAYG;AACH,SAAgB,eAAe,CAAC,MAAe;IAC7C,IAAI,CAAC;QACH,IAAI,CAAC,CAAC,MAAM,YAAY,KAAK,CAAC,EAAE,CAAC;YAC/B,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC;QACxB,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QAC/B,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC;QAEzB,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YAC1C,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,sEAAsE;QACtE,2EAA2E;QAC3E,gEAAgE;QAChE,OAAO,GAAG,OAAO,KAAK,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,eAAe,CAAC;IACzB,CAAC;AACH,CAAC","sourcesContent":["/**\n * Stringifies a rejection reason without ever throwing: `String(reason)`\n * throws when the reason has a hostile `toString`/`Symbol.toPrimitive`. If the\n * reason is an error with a `cause`, the cause is appended, so the wrapped\n * failure (e.g. the underlying network error) is part of the reported reason.\n *\n * Intended for building human-readable failure reasons (e.g. for\n * `AccountSyncFailure.reason`), where wrapper errors would otherwise hide the\n * original failure behind a generic message.\n *\n * @param reason - The rejection reason to stringify.\n * @returns The reason as a string, or a placeholder when stringification fails.\n */\nexport function stringifyReason(reason: unknown): string {\n  try {\n    if (!(reason instanceof Error)) {\n      return String(reason);\n    }\n\n    const message = String(reason);\n    const { cause } = reason;\n\n    if (cause === null || cause === undefined) {\n      return message;\n    }\n\n    // Deliberately permissive: any cause detail is worth reporting, and a\n    // pathological value still ends up as the placeholder via the outer catch.\n    // eslint-disable-next-line @typescript-eslint/no-base-to-string\n    return `${message} (${String(cause)})`;\n  } catch {\n    return 'Unknown error';\n  }\n}\n"]}

package/dist/utils/errors/stringifyReason.d.cts

@@ -0,0 +1,15 @@
+/**
+ * Stringifies a rejection reason without ever throwing: `String(reason)`
+ * throws when the reason has a hostile `toString`/`Symbol.toPrimitive`. If the
+ * reason is an error with a `cause`, the cause is appended, so the wrapped
+ * failure (e.g. the underlying network error) is part of the reported reason.
+ *
+ * Intended for building human-readable failure reasons (e.g. for
+ * `AccountSyncFailure.reason`), where wrapper errors would otherwise hide the
+ * original failure behind a generic message.
+ *
+ * @param reason - The rejection reason to stringify.
+ * @returns The reason as a string, or a placeholder when stringification fails.
+ */
+export declare function stringifyReason(reason: unknown): string;
+//# sourceMappingURL=stringifyReason.d.cts.map

package/dist/utils/errors/stringifyReason.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringifyReason.d.cts","sourceRoot":"","sources":["../../../src/utils/errors/stringifyReason.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAoBvD"}

package/dist/utils/errors/stringifyReason.d.mts

@@ -0,0 +1,15 @@
+/**
+ * Stringifies a rejection reason without ever throwing: `String(reason)`
+ * throws when the reason has a hostile `toString`/`Symbol.toPrimitive`. If the
+ * reason is an error with a `cause`, the cause is appended, so the wrapped
+ * failure (e.g. the underlying network error) is part of the reported reason.
+ *
+ * Intended for building human-readable failure reasons (e.g. for
+ * `AccountSyncFailure.reason`), where wrapper errors would otherwise hide the
+ * original failure behind a generic message.
+ *
+ * @param reason - The rejection reason to stringify.
+ * @returns The reason as a string, or a placeholder when stringification fails.
+ */
+export declare function stringifyReason(reason: unknown): string;
+//# sourceMappingURL=stringifyReason.d.mts.map

package/dist/utils/errors/stringifyReason.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringifyReason.d.mts","sourceRoot":"","sources":["../../../src/utils/errors/stringifyReason.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAoBvD"}

package/dist/utils/errors/stringifyReason.mjs

@@ -0,0 +1,33 @@
+/**
+ * Stringifies a rejection reason without ever throwing: `String(reason)`
+ * throws when the reason has a hostile `toString`/`Symbol.toPrimitive`. If the
+ * reason is an error with a `cause`, the cause is appended, so the wrapped
+ * failure (e.g. the underlying network error) is part of the reported reason.
+ *
+ * Intended for building human-readable failure reasons (e.g. for
+ * `AccountSyncFailure.reason`), where wrapper errors would otherwise hide the
+ * original failure behind a generic message.
+ *
+ * @param reason - The rejection reason to stringify.
+ * @returns The reason as a string, or a placeholder when stringification fails.
+ */
+export function stringifyReason(reason) {
+    try {
+        if (!(reason instanceof Error)) {
+            return String(reason);
+        }
+        const message = String(reason);
+        const { cause } = reason;
+        if (cause === null || cause === undefined) {
+            return message;
+        }
+        // Deliberately permissive: any cause detail is worth reporting, and a
+        // pathological value still ends up as the placeholder via the outer catch.
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        return `${message} (${String(cause)})`;
+    }
+    catch {
+        return 'Unknown error';
+    }
+}
+//# sourceMappingURL=stringifyReason.mjs.map

package/dist/utils/errors/stringifyReason.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringifyReason.mjs","sourceRoot":"","sources":["../../../src/utils/errors/stringifyReason.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,eAAe,CAAC,MAAe;IAC7C,IAAI,CAAC;QACH,IAAI,CAAC,CAAC,MAAM,YAAY,KAAK,CAAC,EAAE,CAAC;YAC/B,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC;QACxB,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QAC/B,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC;QAEzB,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YAC1C,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,sEAAsE;QACtE,2EAA2E;QAC3E,gEAAgE;QAChE,OAAO,GAAG,OAAO,KAAK,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,eAAe,CAAC;IACzB,CAAC;AACH,CAAC","sourcesContent":["/**\n * Stringifies a rejection reason without ever throwing: `String(reason)`\n * throws when the reason has a hostile `toString`/`Symbol.toPrimitive`. If the\n * reason is an error with a `cause`, the cause is appended, so the wrapped\n * failure (e.g. the underlying network error) is part of the reported reason.\n *\n * Intended for building human-readable failure reasons (e.g. for\n * `AccountSyncFailure.reason`), where wrapper errors would otherwise hide the\n * original failure behind a generic message.\n *\n * @param reason - The rejection reason to stringify.\n * @returns The reason as a string, or a placeholder when stringification fails.\n */\nexport function stringifyReason(reason: unknown): string {\n  try {\n    if (!(reason instanceof Error)) {\n      return String(reason);\n    }\n\n    const message = String(reason);\n    const { cause } = reason;\n\n    if (cause === null || cause === undefined) {\n      return message;\n    }\n\n    // Deliberately permissive: any cause detail is worth reporting, and a\n    // pathological value still ends up as the placeholder via the outer catch.\n    // eslint-disable-next-line @typescript-eslint/no-base-to-string\n    return `${message} (${String(cause)})`;\n  } catch {\n    return 'Unknown error';\n  }\n}\n"]}

package/dist/utils/errors/syncError.cjs

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SynchronizationError = void 0;
+exports.getSyncFailuresFromSettledResult = getSyncFailuresFromSettledResult;
+exports.formatAccountSyncFailures = formatAccountSyncFailures;
+const stringifyReason_1 = require("./stringifyReason.cjs");
+/**
+ * Maps settled synchronization results to account synchronization failures:
+ * each rejection is attributed to the account ID at the same index
+ * (`Promise.allSettled` preserves order).
+ *
+ * Rejection reasons are stringified with {@link stringifyReason}, so wrapped
+ * errors report their cause as well.
+ *
+ * @param results - The settled synchronization results.
+ * @param accountIds - The account IDs, in the same order as `results`.
+ * @returns The collected failures, in results order.
+ */
+function getSyncFailuresFromSettledResult(results, accountIds) {
+    const failures = [];
+    results.forEach((result, index) => {
+        const accountId = accountIds[index];
+        if (accountId && result.status === 'rejected') {
+            failures.push({
+                accountId,
+                reason: (0, stringifyReason_1.stringifyReason)(result.reason),
+            });
+        }
+    });
+    return failures;
+}
+/**
+ * Maximum number of characters kept from each failure reason. Reasons can be
+ * arbitrarily long (e.g. full network error messages), so they are truncated
+ * to keep the error message readable in Sentry.
+ */
+const MAX_REASON_LENGTH = 300;
+/**
+ * Maximum number of failures listed in the error message. When more accounts
+ * fail, the remaining ones are summarized with a `+N more` suffix.
+ */
+const MAX_LISTED_FAILURES = 10;
+/**
+ * Formats account synchronization failures as a compact, single-line summary.
+ *
+ * The summary is intended to be embedded in the error message of a
+ * `SynchronizationError`: error tracking via `snap_trackError` serializes only
+ * the error's `name`, `message`, `stack`, and `cause`, so any details stored in
+ * other properties (e.g. a `data` field) are lost before reaching Sentry.
+ *
+ * @param failures - The account synchronization failures to format.
+ * @returns A single-line summary of the failures, truncated to keep the
+ * message readable.
+ */
+function formatAccountSyncFailures(failures) {
+    const listed = failures.slice(0, MAX_LISTED_FAILURES);
+    const details = listed.map((failure) => {
+        const reason = failure.reason.length > MAX_REASON_LENGTH
+            ? `${failure.reason.slice(0, MAX_REASON_LENGTH)}…`
+            : failure.reason;
+        return `${failure.accountId}: ${reason}`;
+    });
+    const remaining = failures.length - listed.length;
+    const suffix = remaining > 0 ? `; +${remaining} more` : '';
+    return `${details.join('; ')}${suffix}`;
+}
+/**
+ * Error thrown when one or more accounts fail to synchronize.
+ *
+ * The failure details are embedded in the message (not only in a property) so
+ * that they survive error tracking: `snap_trackError` serializes only the
+ * error's `name`, `message`, `stack`, and `cause`.
+ */
+class SynchronizationError extends Error {
+    /**
+     * The structured list of account synchronization failures. Useful for logs;
+     * note that it is not preserved by error tracking.
+     */
+    failures;
+    /**
+     * Construct a new synchronization error.
+     *
+     * @param message - The error message, e.g. `'Account synchronization failures'`.
+     * @param failures - The per-account failures to append to the message.
+     * @param options - Additional error options.
+     * @param options.cause - The underlying error that caused the synchronization failure, if any.
+     */
+    constructor(message, failures = [], options) {
+        const details = failures.length > 0
+            ? ` (${failures.length} failed): ${formatAccountSyncFailures(failures)}`
+            : '';
+        super(`${message}${details}`, options);
+        this.name = 'SynchronizationError';
+        this.failures = failures;
+    }
+}
+exports.SynchronizationError = SynchronizationError;
+//# sourceMappingURL=syncError.cjs.map

package/dist/utils/errors/syncError.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncError.cjs","sourceRoot":"","sources":["../../../src/utils/errors/syncError.ts"],"names":[],"mappings":";;;AAyBA,4EAiBC;AA2BD,8DAiBC;AAtFD,2DAAoD;AAapD;;;;;;;;;;;GAWG;AACH,SAAgB,gCAAgC,CAC9C,OAAwC,EACxC,UAAoB;IAEpB,MAAM,QAAQ,GAAyB,EAAE,CAAC;IAE1C,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;QAChC,MAAM,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;QACpC,IAAI,SAAS,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YAC9C,QAAQ,CAAC,IAAI,CAAC;gBACZ,SAAS;gBACT,MAAM,EAAE,IAAA,iCAAe,EAAC,MAAM,CAAC,MAAM,CAAC;aACvC,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;GAIG;AACH,MAAM,iBAAiB,GAAG,GAAG,CAAC;AAE9B;;;GAGG;AACH,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAE/B;;;;;;;;;;;GAWG;AACH,SAAgB,yBAAyB,CACvC,QAA8B;IAE9B,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,mBAAmB,CAAC,CAAC;IACtD,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;QACrC,MAAM,MAAM,GACV,OAAO,CAAC,MAAM,CAAC,MAAM,GAAG,iBAAiB;YACvC,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,iBAAiB,CAAC,GAAG;YAClD,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;QAErB,OAAO,GAAG,OAAO,CAAC,SAAS,KAAK,MAAM,EAAE,CAAC;IAC3C,CAAC,CAAC,CAAC;IAEH,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAClD,MAAM,MAAM,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,SAAS,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;IAE3D,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,MAAM,EAAE,CAAC;AAC1C,CAAC;AAED;;;;;;GAMG;AACH,MAAa,oBAAqB,SAAQ,KAAK;IAC7C;;;OAGG;IACM,QAAQ,CAAuB;IAExC;;;;;;;OAOG;IACH,YACE,OAAe,EACf,WAAiC,EAAE,EACnC,OAAsB;QAEtB,MAAM,OAAO,GACX,QAAQ,CAAC,MAAM,GAAG,CAAC;YACjB,CAAC,CAAC,KAAK,QAAQ,CAAC,MAAM,aAAa,yBAAyB,CAAC,QAAQ,CAAC,EAAE;YACxE,CAAC,CAAC,EAAE,CAAC;QAET,KAAK,CAAC,GAAG,OAAO,GAAG,OAAO,EAAE,EAAE,OAAO,CAAC,CAAC;QACvC,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;QACnC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;CACF;AA7BD,oDA6BC","sourcesContent":["import { stringifyReason } from './stringifyReason';\n\n/**\n * A single account synchronization failure, with enough context to understand\n * which account failed and why.\n */\nexport type AccountSyncFailure = {\n  /** The ID of the account that failed to synchronize. */\n  accountId: string;\n  /** The failure reason, as a human-readable string. */\n  reason: string;\n};\n\n/**\n * Maps settled synchronization results to account synchronization failures:\n * each rejection is attributed to the account ID at the same index\n * (`Promise.allSettled` preserves order).\n *\n * Rejection reasons are stringified with {@link stringifyReason}, so wrapped\n * errors report their cause as well.\n *\n * @param results - The settled synchronization results.\n * @param accountIds - The account IDs, in the same order as `results`.\n * @returns The collected failures, in results order.\n */\nexport function getSyncFailuresFromSettledResult(\n  results: PromiseSettledResult<unknown>[],\n  accountIds: string[],\n): AccountSyncFailure[] {\n  const failures: AccountSyncFailure[] = [];\n\n  results.forEach((result, index) => {\n    const accountId = accountIds[index];\n    if (accountId && result.status === 'rejected') {\n      failures.push({\n        accountId,\n        reason: stringifyReason(result.reason),\n      });\n    }\n  });\n\n  return failures;\n}\n\n/**\n * Maximum number of characters kept from each failure reason. Reasons can be\n * arbitrarily long (e.g. full network error messages), so they are truncated\n * to keep the error message readable in Sentry.\n */\nconst MAX_REASON_LENGTH = 300;\n\n/**\n * Maximum number of failures listed in the error message. When more accounts\n * fail, the remaining ones are summarized with a `+N more` suffix.\n */\nconst MAX_LISTED_FAILURES = 10;\n\n/**\n * Formats account synchronization failures as a compact, single-line summary.\n *\n * The summary is intended to be embedded in the error message of a\n * `SynchronizationError`: error tracking via `snap_trackError` serializes only\n * the error's `name`, `message`, `stack`, and `cause`, so any details stored in\n * other properties (e.g. a `data` field) are lost before reaching Sentry.\n *\n * @param failures - The account synchronization failures to format.\n * @returns A single-line summary of the failures, truncated to keep the\n * message readable.\n */\nexport function formatAccountSyncFailures(\n  failures: AccountSyncFailure[],\n): string {\n  const listed = failures.slice(0, MAX_LISTED_FAILURES);\n  const details = listed.map((failure) => {\n    const reason =\n      failure.reason.length > MAX_REASON_LENGTH\n        ? `${failure.reason.slice(0, MAX_REASON_LENGTH)}…`\n        : failure.reason;\n\n    return `${failure.accountId}: ${reason}`;\n  });\n\n  const remaining = failures.length - listed.length;\n  const suffix = remaining > 0 ? `; +${remaining} more` : '';\n\n  return `${details.join('; ')}${suffix}`;\n}\n\n/**\n * Error thrown when one or more accounts fail to synchronize.\n *\n * The failure details are embedded in the message (not only in a property) so\n * that they survive error tracking: `snap_trackError` serializes only the\n * error's `name`, `message`, `stack`, and `cause`.\n */\nexport class SynchronizationError extends Error {\n  /**\n   * The structured list of account synchronization failures. Useful for logs;\n   * note that it is not preserved by error tracking.\n   */\n  readonly failures: AccountSyncFailure[];\n\n  /**\n   * Construct a new synchronization error.\n   *\n   * @param message - The error message, e.g. `'Account synchronization failures'`.\n   * @param failures - The per-account failures to append to the message.\n   * @param options - Additional error options.\n   * @param options.cause - The underlying error that caused the synchronization failure, if any.\n   */\n  constructor(\n    message: string,\n    failures: AccountSyncFailure[] = [],\n    options?: ErrorOptions,\n  ) {\n    const details =\n      failures.length > 0\n        ? ` (${failures.length} failed): ${formatAccountSyncFailures(failures)}`\n        : '';\n\n    super(`${message}${details}`, options);\n    this.name = 'SynchronizationError';\n    this.failures = failures;\n  }\n}\n"]}