@metamask/snap-networks-utils 1.0.0 → 2.0.0

package/dist/utils/config/envStructs.d.mts

@@ -0,0 +1,57 @@
+import type { Struct } from "@metamask/superstruct";
+/**
+ * Create a struct for environment variables validated against the given
+ * struct, where unset and empty strings (the build-time injection default)
+ * mean the variable is not set.
+ *
+ * @param item - The struct to validate the value against when it is set,
+ * e.g. `UrlStruct`.
+ * @returns A struct that parses to the value or `undefined`.
+ * @example
+ * const PriceApiBaseUrlStruct = emptyToUndefined(UrlStruct);
+ */
+export declare const emptyToUndefined: <Type>(item: Struct<Type>) => Struct<Type | undefined>;
+/**
+ * Create a struct for comma-separated list environment variables.
+ *
+ * The raw string is split on commas and each item is validated against the
+ * given item struct.
+ *
+ * @param item - The struct to validate each list item against.
+ * @returns A struct that parses a comma-separated string into an array.
+ * @example
+ * const RpcUrlListStruct = commaSeparatedListOf(UrlStruct);
+ */
+export declare const commaSeparatedListOf: <Type>(item: Struct<Type>) => Struct<Type[]>;
+/**
+ * Create a struct for a URL environment variable with a fallback: unset,
+ * empty, and whitespace-only values (the build-time injection default)
+ * resolve to the fallback, surrounding whitespace is trimmed, and invalid
+ * values are rejected.
+ *
+ * @param fallback - The URL to use when the variable is unset, empty, or
+ * whitespace-only.
+ * @returns A struct that parses to the URL.
+ * @example
+ * const EsploraUrlStruct = defaultedUrlStruct('https://blockstream.info/api');
+ */
+export declare const defaultedUrlStruct: (fallback: string) => Struct<string>;
+/**
+ * Create a struct that parses an integer from a string, with a minimum value
+ * and a default for unset variables.
+ *
+ * @param minValue - The minimum value for the integer.
+ * @param defaultValue - The default value for the integer.
+ * @returns A struct that parses an integer from a string.
+ */
+export declare const parseIntegerStruct: (minValue: number, defaultValue: number) => Struct<number>;
+/**
+ * Create a struct that parses a float from a string, with a minimum value and
+ * a default for unset variables.
+ *
+ * @param minValue - The minimum value for the float.
+ * @param defaultValue - The default value for the float.
+ * @returns A struct that parses a float from a string.
+ */
+export declare const parseFloatStruct: (minValue: number, defaultValue: number) => Struct<number>;
+//# sourceMappingURL=envStructs.d.mts.map

package/dist/utils/config/envStructs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envStructs.d.mts","sourceRoot":"","sources":["../../../src/utils/config/envStructs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,8BAA8B;AAapD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,GAAI,IAAI,EACnC,MAAM,MAAM,CAAC,IAAI,CAAC,KACjB,MAAM,CAAC,IAAI,GAAG,SAAS,CAGvB,CAAC;AAEJ;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,GAAI,IAAI,EACvC,MAAM,MAAM,CAAC,IAAI,CAAC,KACjB,MAAM,CAAC,IAAI,EAAE,CACoD,CAAC;AAErE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,KAAG,MAAM,CAAC,MAAM,CAI/D,CAAC;AAEL;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAC7B,UAAU,MAAM,EAChB,cAAc,MAAM,KACnB,MAAM,CAAC,MAAM,CAKb,CAAC;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAC3B,UAAU,MAAM,EAChB,cAAc,MAAM,KACnB,MAAM,CAAC,MAAM,CAKb,CAAC"}

package/dist/utils/config/envStructs.mjs

@@ -0,0 +1,61 @@
+import { array, coerce, defaulted, min, number, optional, string } from "@metamask/superstruct";
+import { UrlStruct } from "../urlStruct/urlStruct.mjs";
+/**
+ * Create a struct for environment variables validated against the given
+ * struct, where unset and empty strings (the build-time injection default)
+ * mean the variable is not set.
+ *
+ * @param item - The struct to validate the value against when it is set,
+ * e.g. `UrlStruct`.
+ * @returns A struct that parses to the value or `undefined`.
+ * @example
+ * const PriceApiBaseUrlStruct = emptyToUndefined(UrlStruct);
+ */
+export const emptyToUndefined = (item) => coerce(optional(item), string(), (value) => value === '' ? undefined : value);
+/**
+ * Create a struct for comma-separated list environment variables.
+ *
+ * The raw string is split on commas and each item is validated against the
+ * given item struct.
+ *
+ * @param item - The struct to validate each list item against.
+ * @returns A struct that parses a comma-separated string into an array.
+ * @example
+ * const RpcUrlListStruct = commaSeparatedListOf(UrlStruct);
+ */
+export const commaSeparatedListOf = (item) => coerce(array(item), string(), (value) => value.split(','));
+/**
+ * Create a struct for a URL environment variable with a fallback: unset,
+ * empty, and whitespace-only values (the build-time injection default)
+ * resolve to the fallback, surrounding whitespace is trimmed, and invalid
+ * values are rejected.
+ *
+ * @param fallback - The URL to use when the variable is unset, empty, or
+ * whitespace-only.
+ * @returns A struct that parses to the URL.
+ * @example
+ * const EsploraUrlStruct = defaultedUrlStruct('https://blockstream.info/api');
+ */
+export const defaultedUrlStruct = (fallback) => coerce(defaulted(UrlStruct, fallback), string(), (value) => {
+    const trimmed = value.trim();
+    return trimmed === '' ? undefined : trimmed;
+});
+/**
+ * Create a struct that parses an integer from a string, with a minimum value
+ * and a default for unset variables.
+ *
+ * @param minValue - The minimum value for the integer.
+ * @param defaultValue - The default value for the integer.
+ * @returns A struct that parses an integer from a string.
+ */
+export const parseIntegerStruct = (minValue, defaultValue) => coerce(defaulted(min(number(), minValue), defaultValue), string(), (value) => (value === '' ? undefined : parseInt(value, 10)));
+/**
+ * Create a struct that parses a float from a string, with a minimum value and
+ * a default for unset variables.
+ *
+ * @param minValue - The minimum value for the float.
+ * @param defaultValue - The default value for the float.
+ * @returns A struct that parses a float from a string.
+ */
+export const parseFloatStruct = (minValue, defaultValue) => coerce(defaulted(min(number(), minValue), defaultValue), string(), (value) => (value === '' ? undefined : parseFloat(value)));
+//# sourceMappingURL=envStructs.mjs.map

package/dist/utils/config/envStructs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"envStructs.mjs","sourceRoot":"","sources":["../../../src/utils/config/envStructs.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,EACL,MAAM,EACN,SAAS,EACT,GAAG,EACH,MAAM,EACN,QAAQ,EACR,MAAM,EACP,8BAA8B;AAE/B,OAAO,EAAE,SAAS,EAAE,mCAA+B;AAEnD;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,IAAkB,EACQ,EAAE,CAC5B,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,KAAa,EAAE,EAAE,CACjD,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CACjC,CAAC;AAEJ;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,IAAkB,EACF,EAAE,CAClB,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,KAAa,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;AAErE;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,QAAgB,EAAkB,EAAE,CACrE,MAAM,CAAC,SAAS,CAAC,SAAS,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,KAAa,EAAE,EAAE;IACjE,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAC7B,OAAO,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC;AAC9C,CAAC,CAAC,CAAC;AAEL;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,QAAgB,EAChB,YAAoB,EACJ,EAAE,CAClB,MAAM,CACJ,SAAS,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,QAAQ,CAAC,EAAE,YAAY,CAAC,EAChD,MAAM,EAAE,EACR,CAAC,KAAa,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,CACpE,CAAC;AAEJ;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,QAAgB,EAChB,YAAoB,EACJ,EAAE,CAClB,MAAM,CACJ,SAAS,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,QAAQ,CAAC,EAAE,YAAY,CAAC,EAChD,MAAM,EAAE,EACR,CAAC,KAAa,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAClE,CAAC","sourcesContent":["import type { Struct } from '@metamask/superstruct';\nimport {\n  array,\n  coerce,\n  defaulted,\n  min,\n  number,\n  optional,\n  string,\n} from '@metamask/superstruct';\n\nimport { UrlStruct } from '../urlStruct/urlStruct';\n\n/**\n * Create a struct for environment variables validated against the given\n * struct, where unset and empty strings (the build-time injection default)\n * mean the variable is not set.\n *\n * @param item - The struct to validate the value against when it is set,\n * e.g. `UrlStruct`.\n * @returns A struct that parses to the value or `undefined`.\n * @example\n * const PriceApiBaseUrlStruct = emptyToUndefined(UrlStruct);\n */\nexport const emptyToUndefined = <Type>(\n  item: Struct<Type>,\n): Struct<Type | undefined> =>\n  coerce(optional(item), string(), (value: string) =>\n    value === '' ? undefined : value,\n  );\n\n/**\n * Create a struct for comma-separated list environment variables.\n *\n * The raw string is split on commas and each item is validated against the\n * given item struct.\n *\n * @param item - The struct to validate each list item against.\n * @returns A struct that parses a comma-separated string into an array.\n * @example\n * const RpcUrlListStruct = commaSeparatedListOf(UrlStruct);\n */\nexport const commaSeparatedListOf = <Type>(\n  item: Struct<Type>,\n): Struct<Type[]> =>\n  coerce(array(item), string(), (value: string) => value.split(','));\n\n/**\n * Create a struct for a URL environment variable with a fallback: unset,\n * empty, and whitespace-only values (the build-time injection default)\n * resolve to the fallback, surrounding whitespace is trimmed, and invalid\n * values are rejected.\n *\n * @param fallback - The URL to use when the variable is unset, empty, or\n * whitespace-only.\n * @returns A struct that parses to the URL.\n * @example\n * const EsploraUrlStruct = defaultedUrlStruct('https://blockstream.info/api');\n */\nexport const defaultedUrlStruct = (fallback: string): Struct<string> =>\n  coerce(defaulted(UrlStruct, fallback), string(), (value: string) => {\n    const trimmed = value.trim();\n    return trimmed === '' ? undefined : trimmed;\n  });\n\n/**\n * Create a struct that parses an integer from a string, with a minimum value\n * and a default for unset variables.\n *\n * @param minValue - The minimum value for the integer.\n * @param defaultValue - The default value for the integer.\n * @returns A struct that parses an integer from a string.\n */\nexport const parseIntegerStruct = (\n  minValue: number,\n  defaultValue: number,\n): Struct<number> =>\n  coerce(\n    defaulted(min(number(), minValue), defaultValue),\n    string(),\n    (value: string) => (value === '' ? undefined : parseInt(value, 10)),\n  );\n\n/**\n * Create a struct that parses a float from a string, with a minimum value and\n * a default for unset variables.\n *\n * @param minValue - The minimum value for the float.\n * @param defaultValue - The default value for the float.\n * @returns A struct that parses a float from a string.\n */\nexport const parseFloatStruct = (\n  minValue: number,\n  defaultValue: number,\n): Struct<number> =>\n  coerce(\n    defaulted(min(number(), minValue), defaultValue),\n    string(),\n    (value: string) => (value === '' ? undefined : parseFloat(value)),\n  );\n"]}

package/dist/utils/config/environmentStruct.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentStruct = exports.Environment = void 0;
+const superstruct_1 = require("@metamask/superstruct");
+/**
+ * The environments a snap can be built for, matched against the
+ * `ENVIRONMENT` build-time injection.
+ */
+exports.Environment = {
+    Local: 'local',
+    Test: 'test',
+    Production: 'production',
+};
+/**
+ * A struct for parsing the environment a snap was built for from an
+ * environment variable. Unknown values are rejected.
+ */
+exports.EnvironmentStruct = (0, superstruct_1.enums)(Object.values(exports.Environment));
+//# sourceMappingURL=environmentStruct.cjs.map

package/dist/utils/config/environmentStruct.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"environmentStruct.cjs","sourceRoot":"","sources":["../../../src/utils/config/environmentStruct.ts"],"names":[],"mappings":";;;AAAA,uDAA8C;AAE9C;;;GAGG;AACU,QAAA,WAAW,GAAG;IACzB,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,UAAU,EAAE,YAAY;CAChB,CAAC;AAIX;;;GAGG;AACU,QAAA,iBAAiB,GAAG,IAAA,mBAAK,EACpC,MAAM,CAAC,MAAM,CAAC,mBAAW,CAAoC,CAC9D,CAAC","sourcesContent":["import { enums } from '@metamask/superstruct';\n\n/**\n * The environments a snap can be built for, matched against the\n * `ENVIRONMENT` build-time injection.\n */\nexport const Environment = {\n  Local: 'local',\n  Test: 'test',\n  Production: 'production',\n} as const;\n\nexport type Environment = (typeof Environment)[keyof typeof Environment];\n\n/**\n * A struct for parsing the environment a snap was built for from an\n * environment variable. Unknown values are rejected.\n */\nexport const EnvironmentStruct = enums(\n  Object.values(Environment) as [Environment, ...Environment[]],\n);\n"]}

package/dist/utils/config/environmentStruct.d.cts

@@ -0,0 +1,20 @@
+/**
+ * The environments a snap can be built for, matched against the
+ * `ENVIRONMENT` build-time injection.
+ */
+export declare const Environment: {
+    readonly Local: "local";
+    readonly Test: "test";
+    readonly Production: "production";
+};
+export type Environment = (typeof Environment)[keyof typeof Environment];
+/**
+ * A struct for parsing the environment a snap was built for from an
+ * environment variable. Unknown values are rejected.
+ */
+export declare const EnvironmentStruct: import("@metamask/superstruct").Struct<Environment, {
+    local: "local";
+    test: "test";
+    production: "production";
+}>;
+//# sourceMappingURL=environmentStruct.d.cts.map

package/dist/utils/config/environmentStruct.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environmentStruct.d.cts","sourceRoot":"","sources":["../../../src/utils/config/environmentStruct.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;CAId,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,CAAC;AAEzE;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;EAE7B,CAAC"}

package/dist/utils/config/environmentStruct.d.mts

@@ -0,0 +1,20 @@
+/**
+ * The environments a snap can be built for, matched against the
+ * `ENVIRONMENT` build-time injection.
+ */
+export declare const Environment: {
+    readonly Local: "local";
+    readonly Test: "test";
+    readonly Production: "production";
+};
+export type Environment = (typeof Environment)[keyof typeof Environment];
+/**
+ * A struct for parsing the environment a snap was built for from an
+ * environment variable. Unknown values are rejected.
+ */
+export declare const EnvironmentStruct: import("@metamask/superstruct").Struct<Environment, {
+    local: "local";
+    test: "test";
+    production: "production";
+}>;
+//# sourceMappingURL=environmentStruct.d.mts.map

package/dist/utils/config/environmentStruct.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environmentStruct.d.mts","sourceRoot":"","sources":["../../../src/utils/config/environmentStruct.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;CAId,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,CAAC;AAEzE;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;EAE7B,CAAC"}

package/dist/utils/config/environmentStruct.mjs

@@ -0,0 +1,16 @@
+import { enums } from "@metamask/superstruct";
+/**
+ * The environments a snap can be built for, matched against the
+ * `ENVIRONMENT` build-time injection.
+ */
+export const Environment = {
+    Local: 'local',
+    Test: 'test',
+    Production: 'production',
+};
+/**
+ * A struct for parsing the environment a snap was built for from an
+ * environment variable. Unknown values are rejected.
+ */
+export const EnvironmentStruct = enums(Object.values(Environment));
+//# sourceMappingURL=environmentStruct.mjs.map

package/dist/utils/config/environmentStruct.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"environmentStruct.mjs","sourceRoot":"","sources":["../../../src/utils/config/environmentStruct.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,8BAA8B;AAE9C;;;GAGG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,UAAU,EAAE,YAAY;CAChB,CAAC;AAIX;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,KAAK,CACpC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAoC,CAC9D,CAAC","sourcesContent":["import { enums } from '@metamask/superstruct';\n\n/**\n * The environments a snap can be built for, matched against the\n * `ENVIRONMENT` build-time injection.\n */\nexport const Environment = {\n  Local: 'local',\n  Test: 'test',\n  Production: 'production',\n} as const;\n\nexport type Environment = (typeof Environment)[keyof typeof Environment];\n\n/**\n * A struct for parsing the environment a snap was built for from an\n * environment variable. Unknown values are rejected.\n */\nexport const EnvironmentStruct = enums(\n  Object.values(Environment) as [Environment, ...Environment[]],\n);\n"]}

package/dist/utils/config/logLevelStruct.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevelStruct = void 0;
+const superstruct_1 = require("@metamask/superstruct");
+const Logger_1 = require("../logger/Logger.cjs");
+/**
+ * A struct for parsing a log level from an environment variable.
+ *
+ * Log levels are tunables, so the value is case-insensitive and defaults to
+ * {@link LogLevel.SILENT} when the variable is unset or empty (the build-time
+ * injection default). Unknown values are rejected.
+ */
+exports.LogLevelStruct = (0, superstruct_1.coerce)((0, superstruct_1.defaulted)((0, superstruct_1.enums)(Object.values(Logger_1.LogLevel)), Logger_1.LogLevel.SILENT), (0, superstruct_1.string)(), (value) => (value === '' ? undefined : value.toLowerCase()));
+//# sourceMappingURL=logLevelStruct.cjs.map

package/dist/utils/config/logLevelStruct.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logLevelStruct.cjs","sourceRoot":"","sources":["../../../src/utils/config/logLevelStruct.ts"],"names":[],"mappings":";;;AAAA,uDAAyE;AAEzE,iDAA4C;AAE5C;;;;;;GAMG;AACU,QAAA,cAAc,GAAG,IAAA,oBAAM,EAClC,IAAA,uBAAS,EACP,IAAA,mBAAK,EAAC,MAAM,CAAC,MAAM,CAAC,iBAAQ,CAA8B,CAAC,EAC3D,iBAAQ,CAAC,MAAM,CAChB,EACD,IAAA,oBAAM,GAAE,EACR,CAAC,KAAa,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CACpE,CAAC","sourcesContent":["import { coerce, defaulted, enums, string } from '@metamask/superstruct';\n\nimport { LogLevel } from '../logger/Logger';\n\n/**\n * A struct for parsing a log level from an environment variable.\n *\n * Log levels are tunables, so the value is case-insensitive and defaults to\n * {@link LogLevel.SILENT} when the variable is unset or empty (the build-time\n * injection default). Unknown values are rejected.\n */\nexport const LogLevelStruct = coerce(\n  defaulted(\n    enums(Object.values(LogLevel) as [LogLevel, ...LogLevel[]]),\n    LogLevel.SILENT,\n  ),\n  string(),\n  (value: string) => (value === '' ? undefined : value.toLowerCase()),\n);\n"]}

package/dist/utils/config/logLevelStruct.d.cts

@@ -0,0 +1,17 @@
+import { LogLevel } from "../logger/Logger.cjs";
+/**
+ * A struct for parsing a log level from an environment variable.
+ *
+ * Log levels are tunables, so the value is case-insensitive and defaults to
+ * {@link LogLevel.SILENT} when the variable is unset or empty (the build-time
+ * injection default). Unknown values are rejected.
+ */
+export declare const LogLevelStruct: import("@metamask/superstruct").Struct<LogLevel, {
+    silent: "silent";
+    error: "error";
+    warn: "warn";
+    info: "info";
+    debug: "debug";
+    trace: "trace";
+}>;
+//# sourceMappingURL=logLevelStruct.d.cts.map

package/dist/utils/config/logLevelStruct.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logLevelStruct.d.cts","sourceRoot":"","sources":["../../../src/utils/config/logLevelStruct.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,6BAAyB;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;EAO1B,CAAC"}

package/dist/utils/config/logLevelStruct.d.mts

@@ -0,0 +1,17 @@
+import { LogLevel } from "../logger/Logger.mjs";
+/**
+ * A struct for parsing a log level from an environment variable.
+ *
+ * Log levels are tunables, so the value is case-insensitive and defaults to
+ * {@link LogLevel.SILENT} when the variable is unset or empty (the build-time
+ * injection default). Unknown values are rejected.
+ */
+export declare const LogLevelStruct: import("@metamask/superstruct").Struct<LogLevel, {
+    silent: "silent";
+    error: "error";
+    warn: "warn";
+    info: "info";
+    debug: "debug";
+    trace: "trace";
+}>;
+//# sourceMappingURL=logLevelStruct.d.mts.map

package/dist/utils/config/logLevelStruct.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logLevelStruct.d.mts","sourceRoot":"","sources":["../../../src/utils/config/logLevelStruct.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,6BAAyB;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;EAO1B,CAAC"}

package/dist/utils/config/logLevelStruct.mjs

@@ -0,0 +1,11 @@
+import { coerce, defaulted, enums, string } from "@metamask/superstruct";
+import { LogLevel } from "../logger/Logger.mjs";
+/**
+ * A struct for parsing a log level from an environment variable.
+ *
+ * Log levels are tunables, so the value is case-insensitive and defaults to
+ * {@link LogLevel.SILENT} when the variable is unset or empty (the build-time
+ * injection default). Unknown values are rejected.
+ */
+export const LogLevelStruct = coerce(defaulted(enums(Object.values(LogLevel)), LogLevel.SILENT), string(), (value) => (value === '' ? undefined : value.toLowerCase()));
+//# sourceMappingURL=logLevelStruct.mjs.map

package/dist/utils/config/logLevelStruct.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logLevelStruct.mjs","sourceRoot":"","sources":["../../../src/utils/config/logLevelStruct.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,8BAA8B;AAEzE,OAAO,EAAE,QAAQ,EAAE,6BAAyB;AAE5C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAClC,SAAS,CACP,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAA8B,CAAC,EAC3D,QAAQ,CAAC,MAAM,CAChB,EACD,MAAM,EAAE,EACR,CAAC,KAAa,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CACpE,CAAC","sourcesContent":["import { coerce, defaulted, enums, string } from '@metamask/superstruct';\n\nimport { LogLevel } from '../logger/Logger';\n\n/**\n * A struct for parsing a log level from an environment variable.\n *\n * Log levels are tunables, so the value is case-insensitive and defaults to\n * {@link LogLevel.SILENT} when the variable is unset or empty (the build-time\n * injection default). Unknown values are rejected.\n */\nexport const LogLevelStruct = coerce(\n  defaulted(\n    enums(Object.values(LogLevel) as [LogLevel, ...LogLevel[]]),\n    LogLevel.SILENT,\n  ),\n  string(),\n  (value: string) => (value === '' ? undefined : value.toLowerCase()),\n);\n"]}

package/dist/utils/config/parseEnv.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnv = void 0;
+const superstruct_1 = require("@metamask/superstruct");
+/**
+ * Parse and validate a raw environment record against a struct.
+ *
+ * This is the fail-fast entry point for building a snap configuration from
+ * build-time injected environment variables. Parsing happens once, when the
+ * configuration provider is constructed; an invalid environment stops the
+ * snap at startup instead of producing undefined behaviour later.
+ *
+ * @param value - The raw environment record, e.g. `process.env` values
+ * collected into an object.
+ * @param struct - The struct describing the expected environment.
+ * @returns The parsed and validated environment.
+ * @throws If the environment does not match the struct.
+ * @example
+ * const env = parseEnv({ RPC_URL: process.env.RPC_URL }, EnvStruct);
+ */
+const parseEnv = (value, struct) => {
+    try {
+        return (0, superstruct_1.create)(value, struct);
+    }
+    catch (error) {
+        throw new Error(`Invalid environment configuration: ${error.message}`);
+    }
+};
+exports.parseEnv = parseEnv;
+//# sourceMappingURL=parseEnv.cjs.map

package/dist/utils/config/parseEnv.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseEnv.cjs","sourceRoot":"","sources":["../../../src/utils/config/parseEnv.ts"],"names":[],"mappings":";;;AAAA,uDAA+C;AAG/C;;;;;;;;;;;;;;;GAeG;AACI,MAAM,QAAQ,GAAG,CACtB,KAA8B,EAC9B,MAAoB,EACd,EAAE;IACR,IAAI,CAAC;QACH,OAAO,IAAA,oBAAM,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAC/B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,sCAAuC,KAAe,CAAC,OAAO,EAAE,CACjE,CAAC;IACJ,CAAC;AACH,CAAC,CAAC;AAXW,QAAA,QAAQ,YAWnB","sourcesContent":["import { create } from '@metamask/superstruct';\nimport type { Struct } from '@metamask/superstruct';\n\n/**\n * Parse and validate a raw environment record against a struct.\n *\n * This is the fail-fast entry point for building a snap configuration from\n * build-time injected environment variables. Parsing happens once, when the\n * configuration provider is constructed; an invalid environment stops the\n * snap at startup instead of producing undefined behaviour later.\n *\n * @param value - The raw environment record, e.g. `process.env` values\n * collected into an object.\n * @param struct - The struct describing the expected environment.\n * @returns The parsed and validated environment.\n * @throws If the environment does not match the struct.\n * @example\n * const env = parseEnv({ RPC_URL: process.env.RPC_URL }, EnvStruct);\n */\nexport const parseEnv = <Type>(\n  value: Record<string, unknown>,\n  struct: Struct<Type>,\n): Type => {\n  try {\n    return create(value, struct);\n  } catch (error) {\n    throw new Error(\n      `Invalid environment configuration: ${(error as Error).message}`,\n    );\n  }\n};\n"]}

package/dist/utils/config/parseEnv.d.cts

@@ -0,0 +1,19 @@
+import type { Struct } from "@metamask/superstruct";
+/**
+ * Parse and validate a raw environment record against a struct.
+ *
+ * This is the fail-fast entry point for building a snap configuration from
+ * build-time injected environment variables. Parsing happens once, when the
+ * configuration provider is constructed; an invalid environment stops the
+ * snap at startup instead of producing undefined behaviour later.
+ *
+ * @param value - The raw environment record, e.g. `process.env` values
+ * collected into an object.
+ * @param struct - The struct describing the expected environment.
+ * @returns The parsed and validated environment.
+ * @throws If the environment does not match the struct.
+ * @example
+ * const env = parseEnv({ RPC_URL: process.env.RPC_URL }, EnvStruct);
+ */
+export declare const parseEnv: <Type>(value: Record<string, unknown>, struct: Struct<Type>) => Type;
+//# sourceMappingURL=parseEnv.d.cts.map

package/dist/utils/config/parseEnv.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseEnv.d.cts","sourceRoot":"","sources":["../../../src/utils/config/parseEnv.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,8BAA8B;AAEpD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ,GAAI,IAAI,EAC3B,OAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,QAAQ,MAAM,CAAC,IAAI,CAAC,KACnB,IAQF,CAAC"}

package/dist/utils/config/parseEnv.d.mts

@@ -0,0 +1,19 @@
+import type { Struct } from "@metamask/superstruct";
+/**
+ * Parse and validate a raw environment record against a struct.
+ *
+ * This is the fail-fast entry point for building a snap configuration from
+ * build-time injected environment variables. Parsing happens once, when the
+ * configuration provider is constructed; an invalid environment stops the
+ * snap at startup instead of producing undefined behaviour later.
+ *
+ * @param value - The raw environment record, e.g. `process.env` values
+ * collected into an object.
+ * @param struct - The struct describing the expected environment.
+ * @returns The parsed and validated environment.
+ * @throws If the environment does not match the struct.
+ * @example
+ * const env = parseEnv({ RPC_URL: process.env.RPC_URL }, EnvStruct);
+ */
+export declare const parseEnv: <Type>(value: Record<string, unknown>, struct: Struct<Type>) => Type;
+//# sourceMappingURL=parseEnv.d.mts.map

package/dist/utils/config/parseEnv.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseEnv.d.mts","sourceRoot":"","sources":["../../../src/utils/config/parseEnv.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,8BAA8B;AAEpD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ,GAAI,IAAI,EAC3B,OAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,QAAQ,MAAM,CAAC,IAAI,CAAC,KACnB,IAQF,CAAC"}

package/dist/utils/config/parseEnv.mjs

@@ -0,0 +1,26 @@
+import { create } from "@metamask/superstruct";
+/**
+ * Parse and validate a raw environment record against a struct.
+ *
+ * This is the fail-fast entry point for building a snap configuration from
+ * build-time injected environment variables. Parsing happens once, when the
+ * configuration provider is constructed; an invalid environment stops the
+ * snap at startup instead of producing undefined behaviour later.
+ *
+ * @param value - The raw environment record, e.g. `process.env` values
+ * collected into an object.
+ * @param struct - The struct describing the expected environment.
+ * @returns The parsed and validated environment.
+ * @throws If the environment does not match the struct.
+ * @example
+ * const env = parseEnv({ RPC_URL: process.env.RPC_URL }, EnvStruct);
+ */
+export const parseEnv = (value, struct) => {
+    try {
+        return create(value, struct);
+    }
+    catch (error) {
+        throw new Error(`Invalid environment configuration: ${error.message}`);
+    }
+};
+//# sourceMappingURL=parseEnv.mjs.map

package/dist/utils/config/parseEnv.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseEnv.mjs","sourceRoot":"","sources":["../../../src/utils/config/parseEnv.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,8BAA8B;AAG/C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,KAA8B,EAC9B,MAAoB,EACd,EAAE;IACR,IAAI,CAAC;QACH,OAAO,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAC/B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,sCAAuC,KAAe,CAAC,OAAO,EAAE,CACjE,CAAC;IACJ,CAAC;AACH,CAAC,CAAC","sourcesContent":["import { create } from '@metamask/superstruct';\nimport type { Struct } from '@metamask/superstruct';\n\n/**\n * Parse and validate a raw environment record against a struct.\n *\n * This is the fail-fast entry point for building a snap configuration from\n * build-time injected environment variables. Parsing happens once, when the\n * configuration provider is constructed; an invalid environment stops the\n * snap at startup instead of producing undefined behaviour later.\n *\n * @param value - The raw environment record, e.g. `process.env` values\n * collected into an object.\n * @param struct - The struct describing the expected environment.\n * @returns The parsed and validated environment.\n * @throws If the environment does not match the struct.\n * @example\n * const env = parseEnv({ RPC_URL: process.env.RPC_URL }, EnvStruct);\n */\nexport const parseEnv = <Type>(\n  value: Record<string, unknown>,\n  struct: Struct<Type>,\n): Type => {\n  try {\n    return create(value, struct);\n  } catch (error) {\n    throw new Error(\n      `Invalid environment configuration: ${(error as Error).message}`,\n    );\n  }\n};\n"]}

package/dist/utils/dedupe/InFlightCoalescer.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InFlightCoalescer = void 0;
+/**
+ * Coalesces concurrent async operations by key: while a call for a key is in
+ * flight, subsequent calls with the same key await the same promise instead of
+ * starting duplicate work. Once a run settles, the next call starts a fresh one.
+ *
+ * Note that coalesced callers share the run's outcome, including rejections.
+ */
+class InFlightCoalescer {
+    #inFlight = new Map();
+    async run(key, fn) {
+        const pending = this.#inFlight.get(key);
+        if (pending) {
+            return pending;
+        }
+        const task = Promise.resolve()
+            .then(fn)
+            .finally(() => {
+            this.#inFlight.delete(key);
+        });
+        this.#inFlight.set(key, task);
+        return task;
+    }
+}
+exports.InFlightCoalescer = InFlightCoalescer;
+//# sourceMappingURL=InFlightCoalescer.cjs.map

package/dist/utils/dedupe/InFlightCoalescer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"InFlightCoalescer.cjs","sourceRoot":"","sources":["../../../src/utils/dedupe/InFlightCoalescer.ts"],"names":[],"mappings":";;;AAAA;;;;;;GAMG;AACH,MAAa,iBAAiB;IACnB,SAAS,GAAG,IAAI,GAAG,EAA4B,CAAC;IAEzD,KAAK,CAAC,GAAG,CAAS,GAAW,EAAE,EAAyB;QACtD,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACxC,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,OAA0B,CAAC;QACpC,CAAC;QAED,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE;aAC3B,IAAI,CAAC,EAAE,CAAC;aACR,OAAO,CAAC,GAAG,EAAE;YACZ,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;QACL,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAE9B,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAlBD,8CAkBC","sourcesContent":["/**\n * Coalesces concurrent async operations by key: while a call for a key is in\n * flight, subsequent calls with the same key await the same promise instead of\n * starting duplicate work. Once a run settles, the next call starts a fresh one.\n *\n * Note that coalesced callers share the run's outcome, including rejections.\n */\nexport class InFlightCoalescer {\n  readonly #inFlight = new Map<string, Promise<unknown>>();\n\n  async run<Result>(key: string, fn: () => Promise<Result>): Promise<Result> {\n    const pending = this.#inFlight.get(key);\n    if (pending) {\n      return pending as Promise<Result>;\n    }\n\n    const task = Promise.resolve()\n      .then(fn)\n      .finally(() => {\n        this.#inFlight.delete(key);\n      });\n    this.#inFlight.set(key, task);\n\n    return task;\n  }\n}\n"]}

package/dist/utils/dedupe/InFlightCoalescer.d.cts

@@ -0,0 +1,12 @@
+/**
+ * Coalesces concurrent async operations by key: while a call for a key is in
+ * flight, subsequent calls with the same key await the same promise instead of
+ * starting duplicate work. Once a run settles, the next call starts a fresh one.
+ *
+ * Note that coalesced callers share the run's outcome, including rejections.
+ */
+export declare class InFlightCoalescer {
+    #private;
+    run<Result>(key: string, fn: () => Promise<Result>): Promise<Result>;
+}
+//# sourceMappingURL=InFlightCoalescer.d.cts.map

package/dist/utils/dedupe/InFlightCoalescer.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InFlightCoalescer.d.cts","sourceRoot":"","sources":["../../../src/utils/dedupe/InFlightCoalescer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,iBAAiB;;IAGtB,GAAG,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;CAe3E"}

package/dist/utils/dedupe/InFlightCoalescer.d.mts

@@ -0,0 +1,12 @@
+/**
+ * Coalesces concurrent async operations by key: while a call for a key is in
+ * flight, subsequent calls with the same key await the same promise instead of
+ * starting duplicate work. Once a run settles, the next call starts a fresh one.
+ *
+ * Note that coalesced callers share the run's outcome, including rejections.
+ */
+export declare class InFlightCoalescer {
+    #private;
+    run<Result>(key: string, fn: () => Promise<Result>): Promise<Result>;
+}
+//# sourceMappingURL=InFlightCoalescer.d.mts.map

package/dist/utils/dedupe/InFlightCoalescer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InFlightCoalescer.d.mts","sourceRoot":"","sources":["../../../src/utils/dedupe/InFlightCoalescer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,iBAAiB;;IAGtB,GAAG,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;CAe3E"}

package/dist/utils/dedupe/InFlightCoalescer.mjs

@@ -0,0 +1,24 @@
+/**
+ * Coalesces concurrent async operations by key: while a call for a key is in
+ * flight, subsequent calls with the same key await the same promise instead of
+ * starting duplicate work. Once a run settles, the next call starts a fresh one.
+ *
+ * Note that coalesced callers share the run's outcome, including rejections.
+ */
+export class InFlightCoalescer {
+    #inFlight = new Map();
+    async run(key, fn) {
+        const pending = this.#inFlight.get(key);
+        if (pending) {
+            return pending;
+        }
+        const task = Promise.resolve()
+            .then(fn)
+            .finally(() => {
+            this.#inFlight.delete(key);
+        });
+        this.#inFlight.set(key, task);
+        return task;
+    }
+}
+//# sourceMappingURL=InFlightCoalescer.mjs.map

package/dist/utils/dedupe/InFlightCoalescer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"InFlightCoalescer.mjs","sourceRoot":"","sources":["../../../src/utils/dedupe/InFlightCoalescer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,OAAO,iBAAiB;IACnB,SAAS,GAAG,IAAI,GAAG,EAA4B,CAAC;IAEzD,KAAK,CAAC,GAAG,CAAS,GAAW,EAAE,EAAyB;QACtD,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACxC,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,OAA0B,CAAC;QACpC,CAAC;QAED,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE;aAC3B,IAAI,CAAC,EAAE,CAAC;aACR,OAAO,CAAC,GAAG,EAAE;YACZ,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;QACL,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAE9B,OAAO,IAAI,CAAC;IACd,CAAC;CACF","sourcesContent":["/**\n * Coalesces concurrent async operations by key: while a call for a key is in\n * flight, subsequent calls with the same key await the same promise instead of\n * starting duplicate work. Once a run settles, the next call starts a fresh one.\n *\n * Note that coalesced callers share the run's outcome, including rejections.\n */\nexport class InFlightCoalescer {\n  readonly #inFlight = new Map<string, Promise<unknown>>();\n\n  async run<Result>(key: string, fn: () => Promise<Result>): Promise<Result> {\n    const pending = this.#inFlight.get(key);\n    if (pending) {\n      return pending as Promise<Result>;\n    }\n\n    const task = Promise.resolve()\n      .then(fn)\n      .finally(() => {\n        this.#inFlight.delete(key);\n      });\n    this.#inFlight.set(key, task);\n\n    return task;\n  }\n}\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"]}