@metamask-previews/snap-networks-utils 1.0.0-preview-623cc13 → 1.0.0-preview-44f19c3d

package/CHANGELOG.md

@@ -11,6 +11,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Add a `UuidStruct` Superstruct for validating UUID v4 strings. ([#243](https://github.com/MetaMask/internal-snaps/pull/243))
 - Add helpers `serialize`, `deserialize`, and `Serializable` for round-tripping `BigNumber`, `bigint`, `Uint8Array`, and `undefined` through snap state ([#197](https://github.com/MetaMask/internal-snaps/pull/197))
+- Add shared snap error utilities to the main package entry point ([#241](https://github.com/MetaMask/internal-snaps/pull/241))
+  - `createWithCatchAndThrowSnapError` for handler-boundary error catching, logging, and Snap RPC normalization
+  - `normalizeError` for converting caught values into Snap RPC errors, with optional custom normalizers via `createWithCatchAndThrowSnapError`'s `normalizeErrorFn` option
+  - `isSnapRpcError` type guard and `SnapRpcError` union type
+- Add shared Sentry error tracking utilities for network snaps ([#246](https://github.com/MetaMask/internal-snaps/pull/246))
+  - `createTrackError` for reporting errors to MetaMask via `snap_trackError`
+  - `createSnapErrorHandling` to wire `createTrackError` and `createWithCatchAndThrowSnapError`
 - Add `InFlightCoalescer`, exported from a new `./dedupe` entry point, which coalesces concurrent async operations by key so callers share one in-flight run ([#149](https://github.com/MetaMask/internal-snaps/pull/149))
 - Add shared async batching utilities. ([#211](https://github.com/MetaMask/internal-snaps/pull/211))
 - Add origin permission helpers ([#193](https://github.com/MetaMask/internal-snaps/pull/193))

package/dist/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateOrigin = exports.DEFAULT_METAMASK_ORIGIN = exports.DEFAULT_DEV_ORIGINS = exports.DEFAULT_PROD_ORIGINS = exports.createOriginPermissions = exports.deserialize = exports.serialize = exports.LogLevel = exports.Logger = exports.chunks = exports.batchesAllWithChunks = exports.batchesAllSettledWithChunks = exports.batchesAllSettled = exports.batchesAll = exports.UuidStruct = exports.UrlStruct = exports.sanitizeUri = exports.sanitizeControlCharacters = exports.buildUrl = exports.safeMerge = exports.RemoteFeatureFlagsProvider = exports.REMOTE_FEATURE_FLAGS_PROVIDER_NAME = exports.AssetsProvider = exports.ASSETS_PROVIDER_NAME = void 0;
+exports.InFlightCoalescer = exports.normalizeError = exports.isSnapRpcError = exports.createWithCatchAndThrowSnapError = exports.createTrackError = exports.createSnapErrorHandling = exports.validateOrigin = exports.DEFAULT_METAMASK_ORIGIN = exports.DEFAULT_DEV_ORIGINS = exports.DEFAULT_PROD_ORIGINS = exports.createOriginPermissions = exports.deserialize = exports.serialize = exports.LogLevel = exports.Logger = exports.chunks = exports.batchesAllWithChunks = exports.batchesAllSettledWithChunks = exports.batchesAllSettled = exports.batchesAll = exports.UuidStruct = exports.UrlStruct = exports.sanitizeUri = exports.sanitizeControlCharacters = exports.buildUrl = exports.safeMerge = exports.RemoteFeatureFlagsProvider = exports.REMOTE_FEATURE_FLAGS_PROVIDER_NAME = exports.AssetsProvider = exports.ASSETS_PROVIDER_NAME = void 0;
 var AssetsProvider_1 = require("./providers/assets/AssetsProvider.cjs");
 Object.defineProperty(exports, "ASSETS_PROVIDER_NAME", { enumerable: true, get: function () { return AssetsProvider_1.ASSETS_PROVIDER_NAME; } });
 Object.defineProperty(exports, "AssetsProvider", { enumerable: true, get: function () { return AssetsProvider_1.AssetsProvider; } });
@@ -37,4 +37,12 @@ Object.defineProperty(exports, "DEFAULT_DEV_ORIGINS", { enumerable: true, get: f
 Object.defineProperty(exports, "DEFAULT_METAMASK_ORIGIN", { enumerable: true, get: function () { return createOriginPermissions_1.DEFAULT_METAMASK_ORIGIN; } });
 var validateOrigin_1 = require("./utils/originPermissions/validateOrigin.cjs");
 Object.defineProperty(exports, "validateOrigin", { enumerable: true, get: function () { return validateOrigin_1.validateOrigin; } });
+var errors_1 = require("./utils/errors/index.cjs");
+Object.defineProperty(exports, "createSnapErrorHandling", { enumerable: true, get: function () { return errors_1.createSnapErrorHandling; } });
+Object.defineProperty(exports, "createTrackError", { enumerable: true, get: function () { return errors_1.createTrackError; } });
+Object.defineProperty(exports, "createWithCatchAndThrowSnapError", { enumerable: true, get: function () { return errors_1.createWithCatchAndThrowSnapError; } });
+Object.defineProperty(exports, "isSnapRpcError", { enumerable: true, get: function () { return errors_1.isSnapRpcError; } });
+Object.defineProperty(exports, "normalizeError", { enumerable: true, get: function () { return errors_1.normalizeError; } });
+var InFlightCoalescer_1 = require("./utils/dedupe/InFlightCoalescer.cjs");
+Object.defineProperty(exports, "InFlightCoalescer", { enumerable: true, get: function () { return InFlightCoalescer_1.InFlightCoalescer; } });
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,wEAI2C;AAHzC,sHAAA,oBAAoB,OAAA;AACpB,gHAAA,cAAc,OAAA;AAGhB,8GAIqE;AAHnE,gJAAA,kCAAkC,OAAA;AAClC,wIAAA,0BAA0B,OAAA;AAG5B,6DAAwD;AAA/C,sGAAA,SAAS,OAAA;AAClB,0DAAqD;AAA5C,oGAAA,QAAQ,OAAA;AAEjB,0DAGmC;AAFjC,qHAAA,yBAAyB,OAAA;AACzB,uGAAA,WAAW,OAAA;AAEb,6DAAwD;AAA/C,sGAAA,SAAS,OAAA;AAClB,gEAA2D;AAAlD,wGAAA,UAAU,OAAA;AACnB,iDAM6B;AAL3B,mGAAA,UAAU,OAAA;AACV,0GAAA,iBAAiB,OAAA;AACjB,oHAAA,2BAA2B,OAAA;AAC3B,6GAAA,oBAAoB,OAAA;AACpB,+FAAA,MAAM,OAAA;AAER,oDAAyD;AAAhD,gGAAA,MAAM,OAAA;AAAE,kGAAA,QAAQ,OAAA;AAQzB,yEAA6E;AAApE,0GAAA,SAAS,OAAA;AAAE,4GAAA,WAAW,OAAA;AAE/B,iGAK2D;AAJzD,kIAAA,uBAAuB,OAAA;AACvB,+HAAA,oBAAoB,OAAA;AACpB,8HAAA,mBAAmB,OAAA;AACnB,kIAAA,uBAAuB,OAAA;AAGzB,+EAA0E;AAAjE,gHAAA,cAAc,OAAA","sourcesContent":["export {\n  ASSETS_PROVIDER_NAME,\n  AssetsProvider,\n  type AssetsProviderMessenger,\n} from './providers/assets/AssetsProvider';\nexport {\n  REMOTE_FEATURE_FLAGS_PROVIDER_NAME,\n  RemoteFeatureFlagsProvider,\n  type RemoteFeatureFlagsProviderMessenger,\n} from './providers/remote-feature-flags/RemoteFeatureFlagsProvider';\nexport { safeMerge } from './utils/safeMerge/safeMerge';\nexport { buildUrl } from './utils/buildUrl/buildUrl';\nexport type { BuildUrlParams } from './utils/buildUrl/buildUrl';\nexport {\n  sanitizeControlCharacters,\n  sanitizeUri,\n} from './utils/sanitize/sanitize';\nexport { UrlStruct } from './utils/urlStruct/urlStruct';\nexport { UuidStruct } from './utils/uuidStruct/uuidStruct';\nexport {\n  batchesAll,\n  batchesAllSettled,\n  batchesAllSettledWithChunks,\n  batchesAllWithChunks,\n  chunks,\n} from './utils/async/async';\nexport { Logger, LogLevel } from './utils/logger/Logger';\nexport type {\n  LoggerOptions,\n  LoggerMethod,\n  LogMethod,\n  LogMethodDecorator,\n  LoggerDecorators,\n} from './utils/logger/Logger';\nexport { serialize, deserialize } from './utils/serialization/serialization';\nexport type { Serializable } from './utils/serialization/types';\nexport {\n  createOriginPermissions,\n  DEFAULT_PROD_ORIGINS,\n  DEFAULT_DEV_ORIGINS,\n  DEFAULT_METAMASK_ORIGIN,\n} from './utils/originPermissions/createOriginPermissions';\nexport type { CreateOriginPermissionsParams } from './utils/originPermissions/createOriginPermissions';\nexport { validateOrigin } from './utils/originPermissions/validateOrigin';\n"]}
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,wEAI2C;AAHzC,sHAAA,oBAAoB,OAAA;AACpB,gHAAA,cAAc,OAAA;AAGhB,8GAIqE;AAHnE,gJAAA,kCAAkC,OAAA;AAClC,wIAAA,0BAA0B,OAAA;AAG5B,6DAAwD;AAA/C,sGAAA,SAAS,OAAA;AAClB,0DAAqD;AAA5C,oGAAA,QAAQ,OAAA;AAEjB,0DAGmC;AAFjC,qHAAA,yBAAyB,OAAA;AACzB,uGAAA,WAAW,OAAA;AAEb,6DAAwD;AAA/C,sGAAA,SAAS,OAAA;AAClB,gEAA2D;AAAlD,wGAAA,UAAU,OAAA;AACnB,iDAM6B;AAL3B,mGAAA,UAAU,OAAA;AACV,0GAAA,iBAAiB,OAAA;AACjB,oHAAA,2BAA2B,OAAA;AAC3B,6GAAA,oBAAoB,OAAA;AACpB,+FAAA,MAAM,OAAA;AAER,oDAAyD;AAAhD,gGAAA,MAAM,OAAA;AAAE,kGAAA,QAAQ,OAAA;AAQzB,yEAA6E;AAApE,0GAAA,SAAS,OAAA;AAAE,4GAAA,WAAW,OAAA;AAE/B,iGAK2D;AAJzD,kIAAA,uBAAuB,OAAA;AACvB,+HAAA,oBAAoB,OAAA;AACpB,8HAAA,mBAAmB,OAAA;AACnB,kIAAA,uBAAuB,OAAA;AAGzB,+EAA0E;AAAjE,gHAAA,cAAc,OAAA;AACvB,mDAMwB;AALtB,iHAAA,uBAAuB,OAAA;AACvB,0GAAA,gBAAgB,OAAA;AAChB,0HAAA,gCAAgC,OAAA;AAChC,wGAAA,cAAc,OAAA;AACd,wGAAA,cAAc,OAAA;AAEhB,0EAAqE;AAA5D,sHAAA,iBAAiB,OAAA","sourcesContent":["export {\n  ASSETS_PROVIDER_NAME,\n  AssetsProvider,\n  type AssetsProviderMessenger,\n} from './providers/assets/AssetsProvider';\nexport {\n  REMOTE_FEATURE_FLAGS_PROVIDER_NAME,\n  RemoteFeatureFlagsProvider,\n  type RemoteFeatureFlagsProviderMessenger,\n} from './providers/remote-feature-flags/RemoteFeatureFlagsProvider';\nexport { safeMerge } from './utils/safeMerge/safeMerge';\nexport { buildUrl } from './utils/buildUrl/buildUrl';\nexport type { BuildUrlParams } from './utils/buildUrl/buildUrl';\nexport {\n  sanitizeControlCharacters,\n  sanitizeUri,\n} from './utils/sanitize/sanitize';\nexport { UrlStruct } from './utils/urlStruct/urlStruct';\nexport { UuidStruct } from './utils/uuidStruct/uuidStruct';\nexport {\n  batchesAll,\n  batchesAllSettled,\n  batchesAllSettledWithChunks,\n  batchesAllWithChunks,\n  chunks,\n} from './utils/async/async';\nexport { Logger, LogLevel } from './utils/logger/Logger';\nexport type {\n  LoggerOptions,\n  LoggerMethod,\n  LogMethod,\n  LogMethodDecorator,\n  LoggerDecorators,\n} from './utils/logger/Logger';\nexport { serialize, deserialize } from './utils/serialization/serialization';\nexport type { Serializable } from './utils/serialization/types';\nexport {\n  createOriginPermissions,\n  DEFAULT_PROD_ORIGINS,\n  DEFAULT_DEV_ORIGINS,\n  DEFAULT_METAMASK_ORIGIN,\n} from './utils/originPermissions/createOriginPermissions';\nexport type { CreateOriginPermissionsParams } from './utils/originPermissions/createOriginPermissions';\nexport { validateOrigin } from './utils/originPermissions/validateOrigin';\nexport {\n  createSnapErrorHandling,\n  createTrackError,\n  createWithCatchAndThrowSnapError,\n  isSnapRpcError,\n  normalizeError,\n} from './utils/errors';\nexport { InFlightCoalescer } from './utils/dedupe/InFlightCoalescer';\nexport type {\n  CreateSnapErrorHandlingOptions,\n  CreateTrackErrorOptions,\n  CreateWithCatchAndThrowSnapErrorOptions,\n  LogErrorFn,\n  NormalizeErrorFn,\n  PrepareErrorForTrackingFn,\n  ShouldTrackErrorFn,\n  SnapRpcError,\n  SnapTrackErrorRequest,\n  TrackErrorCapableProvider,\n  TrackErrorFn,\n} from './utils/errors';\n"]}

package/dist/index.d.cts

@@ -14,4 +14,7 @@ export type { Serializable } from "./utils/serialization/types.cjs";
 export { createOriginPermissions, DEFAULT_PROD_ORIGINS, DEFAULT_DEV_ORIGINS, DEFAULT_METAMASK_ORIGIN, } from "./utils/originPermissions/createOriginPermissions.cjs";
 export type { CreateOriginPermissionsParams } from "./utils/originPermissions/createOriginPermissions.cjs";
 export { validateOrigin } from "./utils/originPermissions/validateOrigin.cjs";
+export { createSnapErrorHandling, createTrackError, createWithCatchAndThrowSnapError, isSnapRpcError, normalizeError, } from "./utils/errors/index.cjs";
+export { InFlightCoalescer } from "./utils/dedupe/InFlightCoalescer.cjs";
+export type { CreateSnapErrorHandlingOptions, CreateTrackErrorOptions, CreateWithCatchAndThrowSnapErrorOptions, LogErrorFn, NormalizeErrorFn, PrepareErrorForTrackingFn, ShouldTrackErrorFn, SnapRpcError, SnapTrackErrorRequest, TrackErrorCapableProvider, TrackErrorFn, } from "./utils/errors/index.cjs";
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,KAAK,uBAAuB,GAC7B,8CAA0C;AAC3C,OAAO,EACL,kCAAkC,EAClC,0BAA0B,EAC1B,KAAK,mCAAmC,GACzC,wEAAoE;AACrE,OAAO,EAAE,SAAS,EAAE,wCAAoC;AACxD,OAAO,EAAE,QAAQ,EAAE,sCAAkC;AACrD,YAAY,EAAE,cAAc,EAAE,sCAAkC;AAChE,OAAO,EACL,yBAAyB,EACzB,WAAW,GACZ,sCAAkC;AACnC,OAAO,EAAE,SAAS,EAAE,wCAAoC;AACxD,OAAO,EAAE,UAAU,EAAE,0CAAsC;AAC3D,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,2BAA2B,EAC3B,oBAAoB,EACpB,MAAM,GACP,gCAA4B;AAC7B,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,kCAA8B;AACzD,YAAY,EACV,aAAa,EACb,YAAY,EACZ,SAAS,EACT,kBAAkB,EAClB,gBAAgB,GACjB,kCAA8B;AAC/B,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,gDAA4C;AAC7E,YAAY,EAAE,YAAY,EAAE,wCAAoC;AAChE,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,GACxB,8DAA0D;AAC3D,YAAY,EAAE,6BAA6B,EAAE,8DAA0D;AACvG,OAAO,EAAE,cAAc,EAAE,qDAAiD"}
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,KAAK,uBAAuB,GAC7B,8CAA0C;AAC3C,OAAO,EACL,kCAAkC,EAClC,0BAA0B,EAC1B,KAAK,mCAAmC,GACzC,wEAAoE;AACrE,OAAO,EAAE,SAAS,EAAE,wCAAoC;AACxD,OAAO,EAAE,QAAQ,EAAE,sCAAkC;AACrD,YAAY,EAAE,cAAc,EAAE,sCAAkC;AAChE,OAAO,EACL,yBAAyB,EACzB,WAAW,GACZ,sCAAkC;AACnC,OAAO,EAAE,SAAS,EAAE,wCAAoC;AACxD,OAAO,EAAE,UAAU,EAAE,0CAAsC;AAC3D,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,2BAA2B,EAC3B,oBAAoB,EACpB,MAAM,GACP,gCAA4B;AAC7B,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,kCAA8B;AACzD,YAAY,EACV,aAAa,EACb,YAAY,EACZ,SAAS,EACT,kBAAkB,EAClB,gBAAgB,GACjB,kCAA8B;AAC/B,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,gDAA4C;AAC7E,YAAY,EAAE,YAAY,EAAE,wCAAoC;AAChE,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,GACxB,8DAA0D;AAC3D,YAAY,EAAE,6BAA6B,EAAE,8DAA0D;AACvG,OAAO,EAAE,cAAc,EAAE,qDAAiD;AAC1E,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,gCAAgC,EAChC,cAAc,EACd,cAAc,GACf,iCAAuB;AACxB,OAAO,EAAE,iBAAiB,EAAE,6CAAyC;AACrE,YAAY,EACV,8BAA8B,EAC9B,uBAAuB,EACvB,uCAAuC,EACvC,UAAU,EACV,gBAAgB,EAChB,yBAAyB,EACzB,kBAAkB,EAClB,YAAY,EACZ,qBAAqB,EACrB,yBAAyB,EACzB,YAAY,GACb,iCAAuB"}

package/dist/index.d.mts

@@ -14,4 +14,7 @@ export type { Serializable } from "./utils/serialization/types.mjs";
 export { createOriginPermissions, DEFAULT_PROD_ORIGINS, DEFAULT_DEV_ORIGINS, DEFAULT_METAMASK_ORIGIN, } from "./utils/originPermissions/createOriginPermissions.mjs";
 export type { CreateOriginPermissionsParams } from "./utils/originPermissions/createOriginPermissions.mjs";
 export { validateOrigin } from "./utils/originPermissions/validateOrigin.mjs";
+export { createSnapErrorHandling, createTrackError, createWithCatchAndThrowSnapError, isSnapRpcError, normalizeError, } from "./utils/errors/index.mjs";
+export { InFlightCoalescer } from "./utils/dedupe/InFlightCoalescer.mjs";
+export type { CreateSnapErrorHandlingOptions, CreateTrackErrorOptions, CreateWithCatchAndThrowSnapErrorOptions, LogErrorFn, NormalizeErrorFn, PrepareErrorForTrackingFn, ShouldTrackErrorFn, SnapRpcError, SnapTrackErrorRequest, TrackErrorCapableProvider, TrackErrorFn, } from "./utils/errors/index.mjs";
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,KAAK,uBAAuB,GAC7B,8CAA0C;AAC3C,OAAO,EACL,kCAAkC,EAClC,0BAA0B,EAC1B,KAAK,mCAAmC,GACzC,wEAAoE;AACrE,OAAO,EAAE,SAAS,EAAE,wCAAoC;AACxD,OAAO,EAAE,QAAQ,EAAE,sCAAkC;AACrD,YAAY,EAAE,cAAc,EAAE,sCAAkC;AAChE,OAAO,EACL,yBAAyB,EACzB,WAAW,GACZ,sCAAkC;AACnC,OAAO,EAAE,SAAS,EAAE,wCAAoC;AACxD,OAAO,EAAE,UAAU,EAAE,0CAAsC;AAC3D,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,2BAA2B,EAC3B,oBAAoB,EACpB,MAAM,GACP,gCAA4B;AAC7B,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,kCAA8B;AACzD,YAAY,EACV,aAAa,EACb,YAAY,EACZ,SAAS,EACT,kBAAkB,EAClB,gBAAgB,GACjB,kCAA8B;AAC/B,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,gDAA4C;AAC7E,YAAY,EAAE,YAAY,EAAE,wCAAoC;AAChE,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,GACxB,8DAA0D;AAC3D,YAAY,EAAE,6BAA6B,EAAE,8DAA0D;AACvG,OAAO,EAAE,cAAc,EAAE,qDAAiD"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,KAAK,uBAAuB,GAC7B,8CAA0C;AAC3C,OAAO,EACL,kCAAkC,EAClC,0BAA0B,EAC1B,KAAK,mCAAmC,GACzC,wEAAoE;AACrE,OAAO,EAAE,SAAS,EAAE,wCAAoC;AACxD,OAAO,EAAE,QAAQ,EAAE,sCAAkC;AACrD,YAAY,EAAE,cAAc,EAAE,sCAAkC;AAChE,OAAO,EACL,yBAAyB,EACzB,WAAW,GACZ,sCAAkC;AACnC,OAAO,EAAE,SAAS,EAAE,wCAAoC;AACxD,OAAO,EAAE,UAAU,EAAE,0CAAsC;AAC3D,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,2BAA2B,EAC3B,oBAAoB,EACpB,MAAM,GACP,gCAA4B;AAC7B,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,kCAA8B;AACzD,YAAY,EACV,aAAa,EACb,YAAY,EACZ,SAAS,EACT,kBAAkB,EAClB,gBAAgB,GACjB,kCAA8B;AAC/B,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,gDAA4C;AAC7E,YAAY,EAAE,YAAY,EAAE,wCAAoC;AAChE,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,GACxB,8DAA0D;AAC3D,YAAY,EAAE,6BAA6B,EAAE,8DAA0D;AACvG,OAAO,EAAE,cAAc,EAAE,qDAAiD;AAC1E,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,gCAAgC,EAChC,cAAc,EACd,cAAc,GACf,iCAAuB;AACxB,OAAO,EAAE,iBAAiB,EAAE,6CAAyC;AACrE,YAAY,EACV,8BAA8B,EAC9B,uBAAuB,EACvB,uCAAuC,EACvC,UAAU,EACV,gBAAgB,EAChB,yBAAyB,EACzB,kBAAkB,EAClB,YAAY,EACZ,qBAAqB,EACrB,yBAAyB,EACzB,YAAY,GACb,iCAAuB"}

package/dist/index.mjs

@@ -10,4 +10,6 @@ export { Logger, LogLevel } from "./utils/logger/Logger.mjs";
 export { serialize, deserialize } from "./utils/serialization/serialization.mjs";
 export { createOriginPermissions, DEFAULT_PROD_ORIGINS, DEFAULT_DEV_ORIGINS, DEFAULT_METAMASK_ORIGIN } from "./utils/originPermissions/createOriginPermissions.mjs";
 export { validateOrigin } from "./utils/originPermissions/validateOrigin.mjs";
+export { createSnapErrorHandling, createTrackError, createWithCatchAndThrowSnapError, isSnapRpcError, normalizeError } from "./utils/errors/index.mjs";
+export { InFlightCoalescer } from "./utils/dedupe/InFlightCoalescer.mjs";
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,cAAc,EAEf,8CAA0C;AAC3C,OAAO,EACL,kCAAkC,EAClC,0BAA0B,EAE3B,wEAAoE;AACrE,OAAO,EAAE,SAAS,EAAE,wCAAoC;AACxD,OAAO,EAAE,QAAQ,EAAE,sCAAkC;AAErD,OAAO,EACL,yBAAyB,EACzB,WAAW,EACZ,sCAAkC;AACnC,OAAO,EAAE,SAAS,EAAE,wCAAoC;AACxD,OAAO,EAAE,UAAU,EAAE,0CAAsC;AAC3D,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,2BAA2B,EAC3B,oBAAoB,EACpB,MAAM,EACP,gCAA4B;AAC7B,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,kCAA8B;AAQzD,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,gDAA4C;AAE7E,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,EACxB,8DAA0D;AAE3D,OAAO,EAAE,cAAc,EAAE,qDAAiD","sourcesContent":["export {\n  ASSETS_PROVIDER_NAME,\n  AssetsProvider,\n  type AssetsProviderMessenger,\n} from './providers/assets/AssetsProvider';\nexport {\n  REMOTE_FEATURE_FLAGS_PROVIDER_NAME,\n  RemoteFeatureFlagsProvider,\n  type RemoteFeatureFlagsProviderMessenger,\n} from './providers/remote-feature-flags/RemoteFeatureFlagsProvider';\nexport { safeMerge } from './utils/safeMerge/safeMerge';\nexport { buildUrl } from './utils/buildUrl/buildUrl';\nexport type { BuildUrlParams } from './utils/buildUrl/buildUrl';\nexport {\n  sanitizeControlCharacters,\n  sanitizeUri,\n} from './utils/sanitize/sanitize';\nexport { UrlStruct } from './utils/urlStruct/urlStruct';\nexport { UuidStruct } from './utils/uuidStruct/uuidStruct';\nexport {\n  batchesAll,\n  batchesAllSettled,\n  batchesAllSettledWithChunks,\n  batchesAllWithChunks,\n  chunks,\n} from './utils/async/async';\nexport { Logger, LogLevel } from './utils/logger/Logger';\nexport type {\n  LoggerOptions,\n  LoggerMethod,\n  LogMethod,\n  LogMethodDecorator,\n  LoggerDecorators,\n} from './utils/logger/Logger';\nexport { serialize, deserialize } from './utils/serialization/serialization';\nexport type { Serializable } from './utils/serialization/types';\nexport {\n  createOriginPermissions,\n  DEFAULT_PROD_ORIGINS,\n  DEFAULT_DEV_ORIGINS,\n  DEFAULT_METAMASK_ORIGIN,\n} from './utils/originPermissions/createOriginPermissions';\nexport type { CreateOriginPermissionsParams } from './utils/originPermissions/createOriginPermissions';\nexport { validateOrigin } from './utils/originPermissions/validateOrigin';\n"]}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,cAAc,EAEf,8CAA0C;AAC3C,OAAO,EACL,kCAAkC,EAClC,0BAA0B,EAE3B,wEAAoE;AACrE,OAAO,EAAE,SAAS,EAAE,wCAAoC;AACxD,OAAO,EAAE,QAAQ,EAAE,sCAAkC;AAErD,OAAO,EACL,yBAAyB,EACzB,WAAW,EACZ,sCAAkC;AACnC,OAAO,EAAE,SAAS,EAAE,wCAAoC;AACxD,OAAO,EAAE,UAAU,EAAE,0CAAsC;AAC3D,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,2BAA2B,EAC3B,oBAAoB,EACpB,MAAM,EACP,gCAA4B;AAC7B,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,kCAA8B;AAQzD,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,gDAA4C;AAE7E,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,EACxB,8DAA0D;AAE3D,OAAO,EAAE,cAAc,EAAE,qDAAiD;AAC1E,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,gCAAgC,EAChC,cAAc,EACd,cAAc,EACf,iCAAuB;AACxB,OAAO,EAAE,iBAAiB,EAAE,6CAAyC","sourcesContent":["export {\n  ASSETS_PROVIDER_NAME,\n  AssetsProvider,\n  type AssetsProviderMessenger,\n} from './providers/assets/AssetsProvider';\nexport {\n  REMOTE_FEATURE_FLAGS_PROVIDER_NAME,\n  RemoteFeatureFlagsProvider,\n  type RemoteFeatureFlagsProviderMessenger,\n} from './providers/remote-feature-flags/RemoteFeatureFlagsProvider';\nexport { safeMerge } from './utils/safeMerge/safeMerge';\nexport { buildUrl } from './utils/buildUrl/buildUrl';\nexport type { BuildUrlParams } from './utils/buildUrl/buildUrl';\nexport {\n  sanitizeControlCharacters,\n  sanitizeUri,\n} from './utils/sanitize/sanitize';\nexport { UrlStruct } from './utils/urlStruct/urlStruct';\nexport { UuidStruct } from './utils/uuidStruct/uuidStruct';\nexport {\n  batchesAll,\n  batchesAllSettled,\n  batchesAllSettledWithChunks,\n  batchesAllWithChunks,\n  chunks,\n} from './utils/async/async';\nexport { Logger, LogLevel } from './utils/logger/Logger';\nexport type {\n  LoggerOptions,\n  LoggerMethod,\n  LogMethod,\n  LogMethodDecorator,\n  LoggerDecorators,\n} from './utils/logger/Logger';\nexport { serialize, deserialize } from './utils/serialization/serialization';\nexport type { Serializable } from './utils/serialization/types';\nexport {\n  createOriginPermissions,\n  DEFAULT_PROD_ORIGINS,\n  DEFAULT_DEV_ORIGINS,\n  DEFAULT_METAMASK_ORIGIN,\n} from './utils/originPermissions/createOriginPermissions';\nexport type { CreateOriginPermissionsParams } from './utils/originPermissions/createOriginPermissions';\nexport { validateOrigin } from './utils/originPermissions/validateOrigin';\nexport {\n  createSnapErrorHandling,\n  createTrackError,\n  createWithCatchAndThrowSnapError,\n  isSnapRpcError,\n  normalizeError,\n} from './utils/errors';\nexport { InFlightCoalescer } from './utils/dedupe/InFlightCoalescer';\nexport type {\n  CreateSnapErrorHandlingOptions,\n  CreateTrackErrorOptions,\n  CreateWithCatchAndThrowSnapErrorOptions,\n  LogErrorFn,\n  NormalizeErrorFn,\n  PrepareErrorForTrackingFn,\n  ShouldTrackErrorFn,\n  SnapRpcError,\n  SnapTrackErrorRequest,\n  TrackErrorCapableProvider,\n  TrackErrorFn,\n} from './utils/errors';\n"]}

package/dist/utils/errors/errors.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeError = normalizeError;
+exports.createWithCatchAndThrowSnapError = createWithCatchAndThrowSnapError;
+const snaps_sdk_1 = require("@metamask/snaps-sdk");
+const snapRpcError_1 = require("./snapRpcError.cjs");
+/**
+ * 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.
+ */
+function normalizeError(error) {
+    return (0, snapRpcError_1.isSnapRpcError)(error)
+        ? error
+        : new snaps_sdk_1.SnapError(error instanceof Error ? error : (0, snaps_sdk_1.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.
+ */
+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.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.cjs","sourceRoot":"","sources":["../../../src/utils/errors/errors.ts"],"names":[],"mappings":";;AAyBA,wCAIC;AAmBD,4EAkBC;AAlED,mDAAiE;AAGjE,qDAAgD;AAchD;;;;;;;GAOG;AACH,SAAgB,cAAc,CAAC,KAAc;IAC3C,OAAO,IAAA,6BAAc,EAAC,KAAK,CAAC;QAC1B,CAAC,CAAC,KAAK;QACP,CAAC,CAAC,IAAI,qBAAS,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAA,2BAAe,EAAC,KAAK,CAAC,CAAC,CAAC;AAC7E,CAAC;AAUD;;;;;;;;GAQG;AACH,SAAgB,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/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,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSnapRpcError = exports.normalizeError = exports.createWithCatchAndThrowSnapError = 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 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 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,uCAA4E;AAAnE,0HAAA,gCAAgC,OAAA;AAAE,wGAAA,cAAc,OAAA;AACzD,mDAAgD;AAAvC,8GAAA,cAAc,OAAA","sourcesContent":["export { createSnapErrorHandling, createTrackError } from './trackError';\nexport { createWithCatchAndThrowSnapError, normalizeError } from './errors';\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,7 @@
+export { createSnapErrorHandling, createTrackError } from "./trackError.cjs";
+export { createWithCatchAndThrowSnapError, normalizeError } from "./errors.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,EAAE,gCAAgC,EAAE,cAAc,EAAE,qBAAiB;AAC5E,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,7 @@
+export { createSnapErrorHandling, createTrackError } from "./trackError.mjs";
+export { createWithCatchAndThrowSnapError, normalizeError } from "./errors.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,EAAE,gCAAgC,EAAE,cAAc,EAAE,qBAAiB;AAC5E,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,4 @@
+export { createSnapErrorHandling, createTrackError } from "./trackError.mjs";
+export { createWithCatchAndThrowSnapError, normalizeError } from "./errors.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,EAAE,gCAAgC,EAAE,cAAc,EAAE,qBAAiB;AAC5E,OAAO,EAAE,cAAc,EAAE,2BAAuB","sourcesContent":["export { createSnapErrorHandling, createTrackError } from './trackError';\nexport { createWithCatchAndThrowSnapError, normalizeError } from './errors';\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/trackError.cjs

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTrackError = createTrackError;
+exports.createSnapErrorHandling = createSnapErrorHandling;
+const snaps_sdk_1 = require("@metamask/snaps-sdk");
+const utils_1 = require("@metamask/utils");
+const errors_1 = require("./errors.cjs");
+function defaultPrepareError(error) {
+    return error instanceof Error ? error : (0, utils_1.ensureError)(error);
+}
+function defaultShouldTrack(error) {
+    return !(error instanceof snaps_sdk_1.UserRejectedRequestError);
+}
+/**
+ * Creates a snap-bound error reporter for MetaMask Sentry (`snap_trackError`).
+ *
+ * RPC failures are caught and logged but never rethrown, so the returned function
+ * is safe to call from already-failing error-handling paths.
+ *
+ * @param options - Snap provider accessor, logger, and optional hooks.
+ * @param options.getSnapProvider - Returns the Snap provider used for `snap_trackError`.
+ * @param options.logError - Logger method used when the tracking RPC fails.
+ * @param options.prepareError - Optional error normalizer before Sentry serialization.
+ * @param options.shouldTrack - Optional filter; defaults to skipping `UserRejectedRequestError`.
+ * @returns A function that reports errors to Sentry when {@link ShouldTrackErrorFn} allows it.
+ */
+function createTrackError({ getSnapProvider, logError, prepareError = defaultPrepareError, shouldTrack = defaultShouldTrack, }) {
+    return async (error) => {
+        if (!shouldTrack(error)) {
+            return undefined;
+        }
+        const params = {
+            error: (0, snaps_sdk_1.getJsonError)(prepareError(error)),
+        };
+        try {
+            return await getSnapProvider().request({
+                method: 'snap_trackError',
+                params,
+            });
+        }
+        catch (trackingError) {
+            logError({ error: trackingError }, 'Failed to track error');
+            return undefined;
+        }
+    };
+}
+/**
+ * Creates snap error handling utilities wired with a shared transport and logger setup.
+ *
+ * @param options - Options for both {@link createTrackError} and
+ * {@link createWithCatchAndThrowSnapError}.
+ * @param options.logError - Logger method used for handler and tracking failures.
+ * @param options.normalizeErrorFn - Optional Snap RPC error normalizer for handler boundaries.
+ * @param options.getSnapProvider - Returns the Snap provider used for `snap_trackError`.
+ * @param options.prepareError - Optional error normalizer before Sentry serialization.
+ * @param options.shouldTrack - Optional tracking filter passed to {@link createTrackError}.
+ * @returns Bound {@link createTrackError trackError} and
+ * {@link createWithCatchAndThrowSnapError withCatchAndThrowSnapError} functions.
+ */
+function createSnapErrorHandling({ logError, normalizeErrorFn, getSnapProvider, prepareError, shouldTrack, }) {
+    const trackError = createTrackError({
+        getSnapProvider,
+        logError,
+        prepareError,
+        shouldTrack,
+    });
+    return {
+        trackError,
+        withCatchAndThrowSnapError: (0, errors_1.createWithCatchAndThrowSnapError)({
+            logError,
+            trackError,
+            normalizeErrorFn,
+        }),
+    };
+}
+//# sourceMappingURL=trackError.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackError.cjs","sourceRoot":"","sources":["../../../src/utils/errors/trackError.ts"],"names":[],"mappings":";;AA0EA,4CAyBC;AAeD,0DA6BC;AA/ID,mDAA6E;AAE7E,2CAA8C;AAO9C,yCAA4D;AA4C5D,SAAS,mBAAmB,CAAC,KAAc;IACzC,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAA,mBAAW,EAAC,KAAK,CAAC,CAAC;AAC7D,CAAC;AAED,SAAS,kBAAkB,CAAC,KAAc;IACxC,OAAO,CAAC,CAAC,KAAK,YAAY,oCAAwB,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,gBAAgB,CAA8C,EAC5E,eAAe,EACf,QAAQ,EACR,YAAY,GAAG,mBAAmB,EAClC,WAAW,GAAG,kBAAkB,GACG;IACnC,OAAO,KAAK,EAAE,KAAc,EAA+B,EAAE;QAC3D,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;YACxB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,MAAM,GAAqB;YAC/B,KAAK,EAAE,IAAA,wBAAY,EAAC,YAAY,CAAC,KAAK,CAAC,CAAC;SACzC,CAAC;QAEF,IAAI,CAAC;YACH,OAAO,MAAM,eAAe,EAAE,CAAC,OAAO,CAAC;gBACrC,MAAM,EAAE,iBAAiB;gBACzB,MAAM;aACP,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,aAAa,EAAE,CAAC;YACvB,QAAQ,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,uBAAuB,CAAC,CAAC;YAC5D,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,uBAAuB,CAErC,EACA,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,WAAW,GAC+B;IAM1C,MAAM,UAAU,GAAG,gBAAgB,CAAC;QAClC,eAAe;QACf,QAAQ;QACR,YAAY;QACZ,WAAW;KACZ,CAAC,CAAC;IAEH,OAAO;QACL,UAAU;QACV,0BAA0B,EAAE,IAAA,yCAAgC,EAAC;YAC3D,QAAQ;YACR,UAAU;YACV,gBAAgB;SACjB,CAAC;KACH,CAAC;AACJ,CAAC","sourcesContent":["import { getJsonError, UserRejectedRequestError } from '@metamask/snaps-sdk';\nimport type { TrackErrorParams, TrackErrorResult } from '@metamask/snaps-sdk';\nimport { ensureError } from '@metamask/utils';\n\nimport type {\n  CreateWithCatchAndThrowSnapErrorOptions,\n  LogErrorFn,\n  TrackErrorFn,\n} from './errors';\nimport { createWithCatchAndThrowSnapError } from './errors';\n\n/**\n * Converts a caught value into an {@link Error} before Sentry serialization.\n */\nexport type PrepareErrorForTrackingFn = (error: unknown) => Error;\n\n/**\n * Determines whether an error should be reported through `snap_trackError`.\n */\nexport type ShouldTrackErrorFn = (error: unknown) => boolean;\n\n/**\n * `snap_trackError` request shape from `@metamask/snaps-sdk`.\n */\nexport type SnapTrackErrorRequest = {\n  method: 'snap_trackError';\n  params: TrackErrorParams;\n};\n\n/**\n * Snap provider surface required for {@link createTrackError}, derived from SDK\n * `snap_trackError` types.\n */\nexport type TrackErrorCapableProvider = {\n  request: (\n    args: SnapTrackErrorRequest,\n  ) => Promise<TrackErrorResult | undefined>;\n};\n\nexport type CreateTrackErrorOptions<\n  TProvider extends TrackErrorCapableProvider = TrackErrorCapableProvider,\n> = {\n  getSnapProvider: () => TProvider;\n  logError: LogErrorFn;\n  prepareError?: PrepareErrorForTrackingFn;\n  shouldTrack?: ShouldTrackErrorFn;\n};\n\nexport type CreateSnapErrorHandlingOptions<\n  TProvider extends TrackErrorCapableProvider = TrackErrorCapableProvider,\n> = Omit<CreateWithCatchAndThrowSnapErrorOptions, 'trackError'> &\n  CreateTrackErrorOptions<TProvider>;\n\nfunction defaultPrepareError(error: unknown): Error {\n  return error instanceof Error ? error : ensureError(error);\n}\n\nfunction defaultShouldTrack(error: unknown): boolean {\n  return !(error instanceof UserRejectedRequestError);\n}\n\n/**\n * Creates a snap-bound error reporter for MetaMask Sentry (`snap_trackError`).\n *\n * RPC failures are caught and logged but never rethrown, so the returned function\n * is safe to call from already-failing error-handling paths.\n *\n * @param options - Snap provider accessor, logger, and optional hooks.\n * @param options.getSnapProvider - Returns the Snap provider used for `snap_trackError`.\n * @param options.logError - Logger method used when the tracking RPC fails.\n * @param options.prepareError - Optional error normalizer before Sentry serialization.\n * @param options.shouldTrack - Optional filter; defaults to skipping `UserRejectedRequestError`.\n * @returns A function that reports errors to Sentry when {@link ShouldTrackErrorFn} allows it.\n */\nexport function createTrackError<TProvider extends TrackErrorCapableProvider>({\n  getSnapProvider,\n  logError,\n  prepareError = defaultPrepareError,\n  shouldTrack = defaultShouldTrack,\n}: CreateTrackErrorOptions<TProvider>): TrackErrorFn {\n  return async (error: unknown): Promise<string | undefined> => {\n    if (!shouldTrack(error)) {\n      return undefined;\n    }\n\n    const params: TrackErrorParams = {\n      error: getJsonError(prepareError(error)),\n    };\n\n    try {\n      return await getSnapProvider().request({\n        method: 'snap_trackError',\n        params,\n      });\n    } catch (trackingError) {\n      logError({ error: trackingError }, 'Failed to track error');\n      return undefined;\n    }\n  };\n}\n\n/**\n * Creates snap error handling utilities wired with a shared transport and logger setup.\n *\n * @param options - Options for both {@link createTrackError} and\n * {@link createWithCatchAndThrowSnapError}.\n * @param options.logError - Logger method used for handler and tracking failures.\n * @param options.normalizeErrorFn - Optional Snap RPC error normalizer for handler boundaries.\n * @param options.getSnapProvider - Returns the Snap provider used for `snap_trackError`.\n * @param options.prepareError - Optional error normalizer before Sentry serialization.\n * @param options.shouldTrack - Optional tracking filter passed to {@link createTrackError}.\n * @returns Bound {@link createTrackError trackError} and\n * {@link createWithCatchAndThrowSnapError withCatchAndThrowSnapError} functions.\n */\nexport function createSnapErrorHandling<\n  TProvider extends TrackErrorCapableProvider,\n>({\n  logError,\n  normalizeErrorFn,\n  getSnapProvider,\n  prepareError,\n  shouldTrack,\n}: CreateSnapErrorHandlingOptions<TProvider>): {\n  trackError: TrackErrorFn;\n  withCatchAndThrowSnapError: ReturnType<\n    typeof createWithCatchAndThrowSnapError\n  >;\n} {\n  const trackError = createTrackError({\n    getSnapProvider,\n    logError,\n    prepareError,\n    shouldTrack,\n  });\n\n  return {\n    trackError,\n    withCatchAndThrowSnapError: createWithCatchAndThrowSnapError({\n      logError,\n      trackError,\n      normalizeErrorFn,\n    }),\n  };\n}\n"]}

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

@@ -0,0 +1,64 @@
+import type { TrackErrorParams, TrackErrorResult } from "@metamask/snaps-sdk";
+import type { CreateWithCatchAndThrowSnapErrorOptions, LogErrorFn, TrackErrorFn } from "./errors.cjs";
+import { createWithCatchAndThrowSnapError } from "./errors.cjs";
+/**
+ * Converts a caught value into an {@link Error} before Sentry serialization.
+ */
+export type PrepareErrorForTrackingFn = (error: unknown) => Error;
+/**
+ * Determines whether an error should be reported through `snap_trackError`.
+ */
+export type ShouldTrackErrorFn = (error: unknown) => boolean;
+/**
+ * `snap_trackError` request shape from `@metamask/snaps-sdk`.
+ */
+export type SnapTrackErrorRequest = {
+    method: 'snap_trackError';
+    params: TrackErrorParams;
+};
+/**
+ * Snap provider surface required for {@link createTrackError}, derived from SDK
+ * `snap_trackError` types.
+ */
+export type TrackErrorCapableProvider = {
+    request: (args: SnapTrackErrorRequest) => Promise<TrackErrorResult | undefined>;
+};
+export type CreateTrackErrorOptions<TProvider extends TrackErrorCapableProvider = TrackErrorCapableProvider> = {
+    getSnapProvider: () => TProvider;
+    logError: LogErrorFn;
+    prepareError?: PrepareErrorForTrackingFn;
+    shouldTrack?: ShouldTrackErrorFn;
+};
+export type CreateSnapErrorHandlingOptions<TProvider extends TrackErrorCapableProvider = TrackErrorCapableProvider> = Omit<CreateWithCatchAndThrowSnapErrorOptions, 'trackError'> & CreateTrackErrorOptions<TProvider>;
+/**
+ * Creates a snap-bound error reporter for MetaMask Sentry (`snap_trackError`).
+ *
+ * RPC failures are caught and logged but never rethrown, so the returned function
+ * is safe to call from already-failing error-handling paths.
+ *
+ * @param options - Snap provider accessor, logger, and optional hooks.
+ * @param options.getSnapProvider - Returns the Snap provider used for `snap_trackError`.
+ * @param options.logError - Logger method used when the tracking RPC fails.
+ * @param options.prepareError - Optional error normalizer before Sentry serialization.
+ * @param options.shouldTrack - Optional filter; defaults to skipping `UserRejectedRequestError`.
+ * @returns A function that reports errors to Sentry when {@link ShouldTrackErrorFn} allows it.
+ */
+export declare function createTrackError<TProvider extends TrackErrorCapableProvider>({ getSnapProvider, logError, prepareError, shouldTrack, }: CreateTrackErrorOptions<TProvider>): TrackErrorFn;
+/**
+ * Creates snap error handling utilities wired with a shared transport and logger setup.
+ *
+ * @param options - Options for both {@link createTrackError} and
+ * {@link createWithCatchAndThrowSnapError}.
+ * @param options.logError - Logger method used for handler and tracking failures.
+ * @param options.normalizeErrorFn - Optional Snap RPC error normalizer for handler boundaries.
+ * @param options.getSnapProvider - Returns the Snap provider used for `snap_trackError`.
+ * @param options.prepareError - Optional error normalizer before Sentry serialization.
+ * @param options.shouldTrack - Optional tracking filter passed to {@link createTrackError}.
+ * @returns Bound {@link createTrackError trackError} and
+ * {@link createWithCatchAndThrowSnapError withCatchAndThrowSnapError} functions.
+ */
+export declare function createSnapErrorHandling<TProvider extends TrackErrorCapableProvider>({ logError, normalizeErrorFn, getSnapProvider, prepareError, shouldTrack, }: CreateSnapErrorHandlingOptions<TProvider>): {
+    trackError: TrackErrorFn;
+    withCatchAndThrowSnapError: ReturnType<typeof createWithCatchAndThrowSnapError>;
+};
+//# sourceMappingURL=trackError.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackError.d.cts","sourceRoot":"","sources":["../../../src/utils/errors/trackError.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,4BAA4B;AAG9E,OAAO,KAAK,EACV,uCAAuC,EACvC,UAAU,EACV,YAAY,EACb,qBAAiB;AAClB,OAAO,EAAE,gCAAgC,EAAE,qBAAiB;AAE5D;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;AAE7D;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,EAAE,CACP,IAAI,EAAE,qBAAqB,KACxB,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAAC;CAC5C,CAAC;AAEF,MAAM,MAAM,uBAAuB,CACjC,SAAS,SAAS,yBAAyB,GAAG,yBAAyB,IACrE;IACF,eAAe,EAAE,MAAM,SAAS,CAAC;IACjC,QAAQ,EAAE,UAAU,CAAC;IACrB,YAAY,CAAC,EAAE,yBAAyB,CAAC;IACzC,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,8BAA8B,CACxC,SAAS,SAAS,yBAAyB,GAAG,yBAAyB,IACrE,IAAI,CAAC,uCAAuC,EAAE,YAAY,CAAC,GAC7D,uBAAuB,CAAC,SAAS,CAAC,CAAC;AAUrC;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,SAAS,yBAAyB,EAAE,EAC5E,eAAe,EACf,QAAQ,EACR,YAAkC,EAClC,WAAgC,GACjC,EAAE,uBAAuB,CAAC,SAAS,CAAC,GAAG,YAAY,CAoBnD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,SAAS,yBAAyB,EAC3C,EACA,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,WAAW,GACZ,EAAE,8BAA8B,CAAC,SAAS,CAAC,GAAG;IAC7C,UAAU,EAAE,YAAY,CAAC;IACzB,0BAA0B,EAAE,UAAU,CACpC,OAAO,gCAAgC,CACxC,CAAC;CACH,CAgBA"}

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

@@ -0,0 +1,64 @@
+import type { TrackErrorParams, TrackErrorResult } from "@metamask/snaps-sdk";
+import type { CreateWithCatchAndThrowSnapErrorOptions, LogErrorFn, TrackErrorFn } from "./errors.mjs";
+import { createWithCatchAndThrowSnapError } from "./errors.mjs";
+/**
+ * Converts a caught value into an {@link Error} before Sentry serialization.
+ */
+export type PrepareErrorForTrackingFn = (error: unknown) => Error;
+/**
+ * Determines whether an error should be reported through `snap_trackError`.
+ */
+export type ShouldTrackErrorFn = (error: unknown) => boolean;
+/**
+ * `snap_trackError` request shape from `@metamask/snaps-sdk`.
+ */
+export type SnapTrackErrorRequest = {
+    method: 'snap_trackError';
+    params: TrackErrorParams;
+};
+/**
+ * Snap provider surface required for {@link createTrackError}, derived from SDK
+ * `snap_trackError` types.
+ */
+export type TrackErrorCapableProvider = {
+    request: (args: SnapTrackErrorRequest) => Promise<TrackErrorResult | undefined>;
+};
+export type CreateTrackErrorOptions<TProvider extends TrackErrorCapableProvider = TrackErrorCapableProvider> = {
+    getSnapProvider: () => TProvider;
+    logError: LogErrorFn;
+    prepareError?: PrepareErrorForTrackingFn;
+    shouldTrack?: ShouldTrackErrorFn;
+};
+export type CreateSnapErrorHandlingOptions<TProvider extends TrackErrorCapableProvider = TrackErrorCapableProvider> = Omit<CreateWithCatchAndThrowSnapErrorOptions, 'trackError'> & CreateTrackErrorOptions<TProvider>;
+/**
+ * Creates a snap-bound error reporter for MetaMask Sentry (`snap_trackError`).
+ *
+ * RPC failures are caught and logged but never rethrown, so the returned function
+ * is safe to call from already-failing error-handling paths.
+ *
+ * @param options - Snap provider accessor, logger, and optional hooks.
+ * @param options.getSnapProvider - Returns the Snap provider used for `snap_trackError`.
+ * @param options.logError - Logger method used when the tracking RPC fails.
+ * @param options.prepareError - Optional error normalizer before Sentry serialization.
+ * @param options.shouldTrack - Optional filter; defaults to skipping `UserRejectedRequestError`.
+ * @returns A function that reports errors to Sentry when {@link ShouldTrackErrorFn} allows it.
+ */
+export declare function createTrackError<TProvider extends TrackErrorCapableProvider>({ getSnapProvider, logError, prepareError, shouldTrack, }: CreateTrackErrorOptions<TProvider>): TrackErrorFn;
+/**
+ * Creates snap error handling utilities wired with a shared transport and logger setup.
+ *
+ * @param options - Options for both {@link createTrackError} and
+ * {@link createWithCatchAndThrowSnapError}.
+ * @param options.logError - Logger method used for handler and tracking failures.
+ * @param options.normalizeErrorFn - Optional Snap RPC error normalizer for handler boundaries.
+ * @param options.getSnapProvider - Returns the Snap provider used for `snap_trackError`.
+ * @param options.prepareError - Optional error normalizer before Sentry serialization.
+ * @param options.shouldTrack - Optional tracking filter passed to {@link createTrackError}.
+ * @returns Bound {@link createTrackError trackError} and
+ * {@link createWithCatchAndThrowSnapError withCatchAndThrowSnapError} functions.
+ */
+export declare function createSnapErrorHandling<TProvider extends TrackErrorCapableProvider>({ logError, normalizeErrorFn, getSnapProvider, prepareError, shouldTrack, }: CreateSnapErrorHandlingOptions<TProvider>): {
+    trackError: TrackErrorFn;
+    withCatchAndThrowSnapError: ReturnType<typeof createWithCatchAndThrowSnapError>;
+};
+//# sourceMappingURL=trackError.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackError.d.mts","sourceRoot":"","sources":["../../../src/utils/errors/trackError.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,4BAA4B;AAG9E,OAAO,KAAK,EACV,uCAAuC,EACvC,UAAU,EACV,YAAY,EACb,qBAAiB;AAClB,OAAO,EAAE,gCAAgC,EAAE,qBAAiB;AAE5D;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;AAE7D;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,EAAE,CACP,IAAI,EAAE,qBAAqB,KACxB,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAAC;CAC5C,CAAC;AAEF,MAAM,MAAM,uBAAuB,CACjC,SAAS,SAAS,yBAAyB,GAAG,yBAAyB,IACrE;IACF,eAAe,EAAE,MAAM,SAAS,CAAC;IACjC,QAAQ,EAAE,UAAU,CAAC;IACrB,YAAY,CAAC,EAAE,yBAAyB,CAAC;IACzC,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,8BAA8B,CACxC,SAAS,SAAS,yBAAyB,GAAG,yBAAyB,IACrE,IAAI,CAAC,uCAAuC,EAAE,YAAY,CAAC,GAC7D,uBAAuB,CAAC,SAAS,CAAC,CAAC;AAUrC;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,SAAS,yBAAyB,EAAE,EAC5E,eAAe,EACf,QAAQ,EACR,YAAkC,EAClC,WAAgC,GACjC,EAAE,uBAAuB,CAAC,SAAS,CAAC,GAAG,YAAY,CAoBnD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,SAAS,yBAAyB,EAC3C,EACA,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,WAAW,GACZ,EAAE,8BAA8B,CAAC,SAAS,CAAC,GAAG;IAC7C,UAAU,EAAE,YAAY,CAAC;IACzB,0BAA0B,EAAE,UAAU,CACpC,OAAO,gCAAgC,CACxC,CAAC;CACH,CAgBA"}

package/dist/utils/errors/trackError.mjs

@@ -0,0 +1,72 @@
+import { getJsonError, UserRejectedRequestError } from "@metamask/snaps-sdk";
+import { ensureError } from "@metamask/utils";
+import { createWithCatchAndThrowSnapError } from "./errors.mjs";
+function defaultPrepareError(error) {
+    return error instanceof Error ? error : ensureError(error);
+}
+function defaultShouldTrack(error) {
+    return !(error instanceof UserRejectedRequestError);
+}
+/**
+ * Creates a snap-bound error reporter for MetaMask Sentry (`snap_trackError`).
+ *
+ * RPC failures are caught and logged but never rethrown, so the returned function
+ * is safe to call from already-failing error-handling paths.
+ *
+ * @param options - Snap provider accessor, logger, and optional hooks.
+ * @param options.getSnapProvider - Returns the Snap provider used for `snap_trackError`.
+ * @param options.logError - Logger method used when the tracking RPC fails.
+ * @param options.prepareError - Optional error normalizer before Sentry serialization.
+ * @param options.shouldTrack - Optional filter; defaults to skipping `UserRejectedRequestError`.
+ * @returns A function that reports errors to Sentry when {@link ShouldTrackErrorFn} allows it.
+ */
+export function createTrackError({ getSnapProvider, logError, prepareError = defaultPrepareError, shouldTrack = defaultShouldTrack, }) {
+    return async (error) => {
+        if (!shouldTrack(error)) {
+            return undefined;
+        }
+        const params = {
+            error: getJsonError(prepareError(error)),
+        };
+        try {
+            return await getSnapProvider().request({
+                method: 'snap_trackError',
+                params,
+            });
+        }
+        catch (trackingError) {
+            logError({ error: trackingError }, 'Failed to track error');
+            return undefined;
+        }
+    };
+}
+/**
+ * Creates snap error handling utilities wired with a shared transport and logger setup.
+ *
+ * @param options - Options for both {@link createTrackError} and
+ * {@link createWithCatchAndThrowSnapError}.
+ * @param options.logError - Logger method used for handler and tracking failures.
+ * @param options.normalizeErrorFn - Optional Snap RPC error normalizer for handler boundaries.
+ * @param options.getSnapProvider - Returns the Snap provider used for `snap_trackError`.
+ * @param options.prepareError - Optional error normalizer before Sentry serialization.
+ * @param options.shouldTrack - Optional tracking filter passed to {@link createTrackError}.
+ * @returns Bound {@link createTrackError trackError} and
+ * {@link createWithCatchAndThrowSnapError withCatchAndThrowSnapError} functions.
+ */
+export function createSnapErrorHandling({ logError, normalizeErrorFn, getSnapProvider, prepareError, shouldTrack, }) {
+    const trackError = createTrackError({
+        getSnapProvider,
+        logError,
+        prepareError,
+        shouldTrack,
+    });
+    return {
+        trackError,
+        withCatchAndThrowSnapError: createWithCatchAndThrowSnapError({
+            logError,
+            trackError,
+            normalizeErrorFn,
+        }),
+    };
+}
+//# sourceMappingURL=trackError.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackError.mjs","sourceRoot":"","sources":["../../../src/utils/errors/trackError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,wBAAwB,EAAE,4BAA4B;AAE7E,OAAO,EAAE,WAAW,EAAE,wBAAwB;AAO9C,OAAO,EAAE,gCAAgC,EAAE,qBAAiB;AA4C5D,SAAS,mBAAmB,CAAC,KAAc;IACzC,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AAC7D,CAAC;AAED,SAAS,kBAAkB,CAAC,KAAc;IACxC,OAAO,CAAC,CAAC,KAAK,YAAY,wBAAwB,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAA8C,EAC5E,eAAe,EACf,QAAQ,EACR,YAAY,GAAG,mBAAmB,EAClC,WAAW,GAAG,kBAAkB,GACG;IACnC,OAAO,KAAK,EAAE,KAAc,EAA+B,EAAE;QAC3D,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;YACxB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,MAAM,GAAqB;YAC/B,KAAK,EAAE,YAAY,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;SACzC,CAAC;QAEF,IAAI,CAAC;YACH,OAAO,MAAM,eAAe,EAAE,CAAC,OAAO,CAAC;gBACrC,MAAM,EAAE,iBAAiB;gBACzB,MAAM;aACP,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,aAAa,EAAE,CAAC;YACvB,QAAQ,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,uBAAuB,CAAC,CAAC;YAC5D,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,uBAAuB,CAErC,EACA,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,WAAW,GAC+B;IAM1C,MAAM,UAAU,GAAG,gBAAgB,CAAC;QAClC,eAAe;QACf,QAAQ;QACR,YAAY;QACZ,WAAW;KACZ,CAAC,CAAC;IAEH,OAAO;QACL,UAAU;QACV,0BAA0B,EAAE,gCAAgC,CAAC;YAC3D,QAAQ;YACR,UAAU;YACV,gBAAgB;SACjB,CAAC;KACH,CAAC;AACJ,CAAC","sourcesContent":["import { getJsonError, UserRejectedRequestError } from '@metamask/snaps-sdk';\nimport type { TrackErrorParams, TrackErrorResult } from '@metamask/snaps-sdk';\nimport { ensureError } from '@metamask/utils';\n\nimport type {\n  CreateWithCatchAndThrowSnapErrorOptions,\n  LogErrorFn,\n  TrackErrorFn,\n} from './errors';\nimport { createWithCatchAndThrowSnapError } from './errors';\n\n/**\n * Converts a caught value into an {@link Error} before Sentry serialization.\n */\nexport type PrepareErrorForTrackingFn = (error: unknown) => Error;\n\n/**\n * Determines whether an error should be reported through `snap_trackError`.\n */\nexport type ShouldTrackErrorFn = (error: unknown) => boolean;\n\n/**\n * `snap_trackError` request shape from `@metamask/snaps-sdk`.\n */\nexport type SnapTrackErrorRequest = {\n  method: 'snap_trackError';\n  params: TrackErrorParams;\n};\n\n/**\n * Snap provider surface required for {@link createTrackError}, derived from SDK\n * `snap_trackError` types.\n */\nexport type TrackErrorCapableProvider = {\n  request: (\n    args: SnapTrackErrorRequest,\n  ) => Promise<TrackErrorResult | undefined>;\n};\n\nexport type CreateTrackErrorOptions<\n  TProvider extends TrackErrorCapableProvider = TrackErrorCapableProvider,\n> = {\n  getSnapProvider: () => TProvider;\n  logError: LogErrorFn;\n  prepareError?: PrepareErrorForTrackingFn;\n  shouldTrack?: ShouldTrackErrorFn;\n};\n\nexport type CreateSnapErrorHandlingOptions<\n  TProvider extends TrackErrorCapableProvider = TrackErrorCapableProvider,\n> = Omit<CreateWithCatchAndThrowSnapErrorOptions, 'trackError'> &\n  CreateTrackErrorOptions<TProvider>;\n\nfunction defaultPrepareError(error: unknown): Error {\n  return error instanceof Error ? error : ensureError(error);\n}\n\nfunction defaultShouldTrack(error: unknown): boolean {\n  return !(error instanceof UserRejectedRequestError);\n}\n\n/**\n * Creates a snap-bound error reporter for MetaMask Sentry (`snap_trackError`).\n *\n * RPC failures are caught and logged but never rethrown, so the returned function\n * is safe to call from already-failing error-handling paths.\n *\n * @param options - Snap provider accessor, logger, and optional hooks.\n * @param options.getSnapProvider - Returns the Snap provider used for `snap_trackError`.\n * @param options.logError - Logger method used when the tracking RPC fails.\n * @param options.prepareError - Optional error normalizer before Sentry serialization.\n * @param options.shouldTrack - Optional filter; defaults to skipping `UserRejectedRequestError`.\n * @returns A function that reports errors to Sentry when {@link ShouldTrackErrorFn} allows it.\n */\nexport function createTrackError<TProvider extends TrackErrorCapableProvider>({\n  getSnapProvider,\n  logError,\n  prepareError = defaultPrepareError,\n  shouldTrack = defaultShouldTrack,\n}: CreateTrackErrorOptions<TProvider>): TrackErrorFn {\n  return async (error: unknown): Promise<string | undefined> => {\n    if (!shouldTrack(error)) {\n      return undefined;\n    }\n\n    const params: TrackErrorParams = {\n      error: getJsonError(prepareError(error)),\n    };\n\n    try {\n      return await getSnapProvider().request({\n        method: 'snap_trackError',\n        params,\n      });\n    } catch (trackingError) {\n      logError({ error: trackingError }, 'Failed to track error');\n      return undefined;\n    }\n  };\n}\n\n/**\n * Creates snap error handling utilities wired with a shared transport and logger setup.\n *\n * @param options - Options for both {@link createTrackError} and\n * {@link createWithCatchAndThrowSnapError}.\n * @param options.logError - Logger method used for handler and tracking failures.\n * @param options.normalizeErrorFn - Optional Snap RPC error normalizer for handler boundaries.\n * @param options.getSnapProvider - Returns the Snap provider used for `snap_trackError`.\n * @param options.prepareError - Optional error normalizer before Sentry serialization.\n * @param options.shouldTrack - Optional tracking filter passed to {@link createTrackError}.\n * @returns Bound {@link createTrackError trackError} and\n * {@link createWithCatchAndThrowSnapError withCatchAndThrowSnapError} functions.\n */\nexport function createSnapErrorHandling<\n  TProvider extends TrackErrorCapableProvider,\n>({\n  logError,\n  normalizeErrorFn,\n  getSnapProvider,\n  prepareError,\n  shouldTrack,\n}: CreateSnapErrorHandlingOptions<TProvider>): {\n  trackError: TrackErrorFn;\n  withCatchAndThrowSnapError: ReturnType<\n    typeof createWithCatchAndThrowSnapError\n  >;\n} {\n  const trackError = createTrackError({\n    getSnapProvider,\n    logError,\n    prepareError,\n    shouldTrack,\n  });\n\n  return {\n    trackError,\n    withCatchAndThrowSnapError: createWithCatchAndThrowSnapError({\n      logError,\n      trackError,\n      normalizeErrorFn,\n    }),\n  };\n}\n"]}

package/dist/utils/logger/__mocks__/Logger.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockLogger = void 0;
+exports.mockLogger = {
+    log: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    debug: jest.fn(),
+    trace: jest.fn(),
+    withPrefix: (prefix) => createPrefixedLogger([prefix]),
+};
+function createPrefixedLogger(prefixes) {
+    return new Proxy(exports.mockLogger, {
+        get(target, property) {
+            if (property === 'withPrefix') {
+                return (prefix) => createPrefixedLogger([...prefixes, prefix]);
+            }
+            const method = target[property];
+            return typeof method === 'function'
+                ? (...args) => method(...prefixes, ...args)
+                : method;
+        },
+    });
+}
+//# sourceMappingURL=Logger.cjs.map

package/dist/utils/logger/__mocks__/Logger.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.cjs","sourceRoot":"","sources":["../../../../src/utils/logger/__mocks__/Logger.ts"],"names":[],"mappings":";;;AAEa,QAAA,UAAU,GAAG;IACxB,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE;IACd,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE;IACf,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE;IACf,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE;IAChB,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE;IAChB,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE;IAChB,UAAU,EAAE,CAAC,MAAc,EAAU,EAAE,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;CACrC,CAAC;AAEpC,SAAS,oBAAoB,CAAC,QAAkB;IAC9C,OAAO,IAAI,KAAK,CAAC,kBAAU,EAAE;QAC3B,GAAG,CAAC,MAAM,EAAE,QAAsB;YAChC,IAAI,QAAQ,KAAK,YAAY,EAAE,CAAC;gBAC9B,OAAO,CAAC,MAAc,EAAE,EAAE,CAAC,oBAAoB,CAAC,CAAC,GAAG,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;YACzE,CAAC;YAED,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;YAChC,OAAO,OAAO,MAAM,KAAK,UAAU;gBACjC,CAAC,CAAC,CAAC,GAAG,IAAe,EAAW,EAAE,CAAC,MAAM,CAAC,GAAG,QAAQ,EAAE,GAAG,IAAI,CAAC;gBAC/D,CAAC,CAAC,MAAM,CAAC;QACb,CAAC;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { Logger } from '../Logger';\n\nexport const mockLogger = {\n  log: jest.fn(),\n  info: jest.fn(),\n  warn: jest.fn(),\n  error: jest.fn(),\n  debug: jest.fn(),\n  trace: jest.fn(),\n  withPrefix: (prefix: string): Logger => createPrefixedLogger([prefix]),\n} as unknown as jest.Mocked<Logger>;\n\nfunction createPrefixedLogger(prefixes: string[]): Logger {\n  return new Proxy(mockLogger, {\n    get(target, property: keyof Logger): unknown {\n      if (property === 'withPrefix') {\n        return (prefix: string) => createPrefixedLogger([...prefixes, prefix]);\n      }\n\n      const method = target[property];\n      return typeof method === 'function'\n        ? (...args: unknown[]): unknown => method(...prefixes, ...args)\n        : method;\n    },\n  });\n}\n"]}

package/dist/utils/logger/__mocks__/Logger.d.cts

@@ -0,0 +1,3 @@
+import type { Logger } from "../Logger.cjs";
+export declare const mockLogger: jest.Mocked<Logger>;
+//# sourceMappingURL=Logger.d.cts.map

package/dist/utils/logger/__mocks__/Logger.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.cts","sourceRoot":"","sources":["../../../../src/utils/logger/__mocks__/Logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,sBAAkB;AAExC,eAAO,MAAM,UAAU,EAQP,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC"}

package/dist/utils/logger/__mocks__/Logger.d.mts

@@ -0,0 +1,3 @@
+import type { Logger } from "../Logger.mjs";
+export declare const mockLogger: jest.Mocked<Logger>;
+//# sourceMappingURL=Logger.d.mts.map

package/dist/utils/logger/__mocks__/Logger.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.mts","sourceRoot":"","sources":["../../../../src/utils/logger/__mocks__/Logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,sBAAkB;AAExC,eAAO,MAAM,UAAU,EAQP,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC"}

package/dist/utils/logger/__mocks__/Logger.mjs

@@ -0,0 +1,23 @@
+export const mockLogger = {
+    log: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    debug: jest.fn(),
+    trace: jest.fn(),
+    withPrefix: (prefix) => createPrefixedLogger([prefix]),
+};
+function createPrefixedLogger(prefixes) {
+    return new Proxy(mockLogger, {
+        get(target, property) {
+            if (property === 'withPrefix') {
+                return (prefix) => createPrefixedLogger([...prefixes, prefix]);
+            }
+            const method = target[property];
+            return typeof method === 'function'
+                ? (...args) => method(...prefixes, ...args)
+                : method;
+        },
+    });
+}
+//# sourceMappingURL=Logger.mjs.map

package/dist/utils/logger/__mocks__/Logger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.mjs","sourceRoot":"","sources":["../../../../src/utils/logger/__mocks__/Logger.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE;IACd,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE;IACf,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE;IACf,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE;IAChB,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE;IAChB,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE;IAChB,UAAU,EAAE,CAAC,MAAc,EAAU,EAAE,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;CACrC,CAAC;AAEpC,SAAS,oBAAoB,CAAC,QAAkB;IAC9C,OAAO,IAAI,KAAK,CAAC,UAAU,EAAE;QAC3B,GAAG,CAAC,MAAM,EAAE,QAAsB;YAChC,IAAI,QAAQ,KAAK,YAAY,EAAE,CAAC;gBAC9B,OAAO,CAAC,MAAc,EAAE,EAAE,CAAC,oBAAoB,CAAC,CAAC,GAAG,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;YACzE,CAAC;YAED,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;YAChC,OAAO,OAAO,MAAM,KAAK,UAAU;gBACjC,CAAC,CAAC,CAAC,GAAG,IAAe,EAAW,EAAE,CAAC,MAAM,CAAC,GAAG,QAAQ,EAAE,GAAG,IAAI,CAAC;gBAC/D,CAAC,CAAC,MAAM,CAAC;QACb,CAAC;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { Logger } from '../Logger';\n\nexport const mockLogger = {\n  log: jest.fn(),\n  info: jest.fn(),\n  warn: jest.fn(),\n  error: jest.fn(),\n  debug: jest.fn(),\n  trace: jest.fn(),\n  withPrefix: (prefix: string): Logger => createPrefixedLogger([prefix]),\n} as unknown as jest.Mocked<Logger>;\n\nfunction createPrefixedLogger(prefixes: string[]): Logger {\n  return new Proxy(mockLogger, {\n    get(target, property: keyof Logger): unknown {\n      if (property === 'withPrefix') {\n        return (prefix: string) => createPrefixedLogger([...prefixes, prefix]);\n      }\n\n      const method = target[property];\n      return typeof method === 'function'\n        ? (...args: unknown[]): unknown => method(...prefixes, ...args)\n        : method;\n    },\n  });\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamask-previews/snap-networks-utils",
-  "version": "1.0.0-preview-623cc13",
+  "version": "1.0.0-preview-44f19c3d",
   "description": "Shared utilities for MetaMask network snaps",
   "keywords": [
     "Ethereum",