@metamask/snap-networks-utils 1.0.0 → 2.0.0

package/dist/utils/cache/useCacheUntil.d.cts

@@ -0,0 +1,54 @@
+import { Logger } from "../logger/Logger.cjs";
+import type { Serializable } from "../serialization/types.cjs";
+import type { ICache } from "./types.cjs";
+/**
+ * Result type for functions that provide their own expiry time.
+ */
+export type ResultWithExpiry<TResult> = {
+    result: TResult;
+    expiresAt: number;
+};
+/**
+ * Options for configuring the caching behavior of a function with dynamic expiry.
+ */
+export type CacheUntilOptions = {
+    /**
+     * Set this if you want to use a custom function name for the cache key.
+     */
+    functionName?: string;
+    /**
+     * Optional function to generate the cache key for the function call.
+     * Defaults to a function that generates the key based on function name and JSON stringified args separated by colons.
+     */
+    generateCacheKey?: (functionName: string, args: Serializable[]) => string;
+    /**
+     * Whether to refresh the cache.
+     * Defaults to false.
+     */
+    refreshCache?: boolean;
+    /**
+     * Optional logger for cache errors. Defaults to a silent logger.
+     */
+    logger?: Logger;
+};
+/**
+ * Wraps an async function with caching behavior where expiry is determined
+ * by the function result itself (dynamic TTL).
+ *
+ * Unlike `useCache` which uses a fixed TTL, this utility allows the wrapped
+ * function to specify when its result expires. This is useful for caching
+ * data that has known invalidation points (e.g., blockchain maintenance periods).
+ *
+ * @template TArgs - Tuple type representing the arguments of the function.
+ * @template TResult - The return type of the function, must be Serializable.
+ * @param fn - The asynchronous function to wrap. Must return a Promise<ResultWithExpiry<TResult>>.
+ * @param cache - The cache instance to use.
+ * @param options - The caching options.
+ * @param options.refreshCache - Whether to refresh the cache.
+ * @param options.functionName - The name of the function.
+ * @param options.generateCacheKey - Optional function to generate the cache key.
+ * @param options.logger - Optional logger for cache errors.
+ * @returns A new asynchronous function with caching behavior.
+ */
+export declare const useCacheUntil: <TArgs extends Serializable[], TResult extends Serializable>(fn: (...args: TArgs) => Promise<ResultWithExpiry<TResult>>, cache: ICache<Serializable>, { functionName, generateCacheKey, refreshCache, logger, }: CacheUntilOptions) => ((...args: TArgs) => Promise<TResult>);
+//# sourceMappingURL=useCacheUntil.d.cts.map

package/dist/utils/cache/useCacheUntil.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCacheUntil.d.cts","sourceRoot":"","sources":["../../../src/utils/cache/useCacheUntil.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAY,6BAAyB;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,mCAA+B;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAgB;AAOtC;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,OAAO,IAAI;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,MAAM,CAAC;IAC1E;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAeF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,GACxB,KAAK,SAAS,YAAY,EAAE,EAC5B,OAAO,SAAS,YAAY,EAE5B,IAAI,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,EAC1D,OAAO,MAAM,CAAC,YAAY,CAAC,EAC3B,2DAKG,iBAAiB,KACnB,CAAC,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,OAAO,CAAC,CAiDvC,CAAC"}

package/dist/utils/cache/useCacheUntil.d.mts

@@ -0,0 +1,54 @@
+import { Logger } from "../logger/Logger.mjs";
+import type { Serializable } from "../serialization/types.mjs";
+import type { ICache } from "./types.mjs";
+/**
+ * Result type for functions that provide their own expiry time.
+ */
+export type ResultWithExpiry<TResult> = {
+    result: TResult;
+    expiresAt: number;
+};
+/**
+ * Options for configuring the caching behavior of a function with dynamic expiry.
+ */
+export type CacheUntilOptions = {
+    /**
+     * Set this if you want to use a custom function name for the cache key.
+     */
+    functionName?: string;
+    /**
+     * Optional function to generate the cache key for the function call.
+     * Defaults to a function that generates the key based on function name and JSON stringified args separated by colons.
+     */
+    generateCacheKey?: (functionName: string, args: Serializable[]) => string;
+    /**
+     * Whether to refresh the cache.
+     * Defaults to false.
+     */
+    refreshCache?: boolean;
+    /**
+     * Optional logger for cache errors. Defaults to a silent logger.
+     */
+    logger?: Logger;
+};
+/**
+ * Wraps an async function with caching behavior where expiry is determined
+ * by the function result itself (dynamic TTL).
+ *
+ * Unlike `useCache` which uses a fixed TTL, this utility allows the wrapped
+ * function to specify when its result expires. This is useful for caching
+ * data that has known invalidation points (e.g., blockchain maintenance periods).
+ *
+ * @template TArgs - Tuple type representing the arguments of the function.
+ * @template TResult - The return type of the function, must be Serializable.
+ * @param fn - The asynchronous function to wrap. Must return a Promise<ResultWithExpiry<TResult>>.
+ * @param cache - The cache instance to use.
+ * @param options - The caching options.
+ * @param options.refreshCache - Whether to refresh the cache.
+ * @param options.functionName - The name of the function.
+ * @param options.generateCacheKey - Optional function to generate the cache key.
+ * @param options.logger - Optional logger for cache errors.
+ * @returns A new asynchronous function with caching behavior.
+ */
+export declare const useCacheUntil: <TArgs extends Serializable[], TResult extends Serializable>(fn: (...args: TArgs) => Promise<ResultWithExpiry<TResult>>, cache: ICache<Serializable>, { functionName, generateCacheKey, refreshCache, logger, }: CacheUntilOptions) => ((...args: TArgs) => Promise<TResult>);
+//# sourceMappingURL=useCacheUntil.d.mts.map

package/dist/utils/cache/useCacheUntil.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCacheUntil.d.mts","sourceRoot":"","sources":["../../../src/utils/cache/useCacheUntil.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAY,6BAAyB;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,mCAA+B;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAgB;AAOtC;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,OAAO,IAAI;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,MAAM,CAAC;IAC1E;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAeF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,GACxB,KAAK,SAAS,YAAY,EAAE,EAC5B,OAAO,SAAS,YAAY,EAE5B,IAAI,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,EAC1D,OAAO,MAAM,CAAC,YAAY,CAAC,EAC3B,2DAKG,iBAAiB,KACnB,CAAC,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,OAAO,CAAC,CAiDvC,CAAC"}

package/dist/utils/cache/useCacheUntil.mjs

@@ -0,0 +1,76 @@
+import { Logger, LogLevel } from "../logger/Logger.mjs";
+import { serialize } from "../serialization/serialization.mjs";
+/**
+ * A logger that discards all messages, used when no logger is provided.
+ */
+const silentLogger = new Logger({ level: LogLevel.SILENT });
+/**
+ * Default function to generate the cache key for a function call.
+ *
+ * @param functionName - The name of the function.
+ * @param args - The arguments of the function call.
+ * @returns The cache key.
+ */
+const defaultGenerateCacheKey = (functionName, args) => `${functionName}:${args.map((arg) => JSON.stringify(serialize(arg))).join(':')}`;
+/**
+ * Wraps an async function with caching behavior where expiry is determined
+ * by the function result itself (dynamic TTL).
+ *
+ * Unlike `useCache` which uses a fixed TTL, this utility allows the wrapped
+ * function to specify when its result expires. This is useful for caching
+ * data that has known invalidation points (e.g., blockchain maintenance periods).
+ *
+ * @template TArgs - Tuple type representing the arguments of the function.
+ * @template TResult - The return type of the function, must be Serializable.
+ * @param fn - The asynchronous function to wrap. Must return a Promise<ResultWithExpiry<TResult>>.
+ * @param cache - The cache instance to use.
+ * @param options - The caching options.
+ * @param options.refreshCache - Whether to refresh the cache.
+ * @param options.functionName - The name of the function.
+ * @param options.generateCacheKey - Optional function to generate the cache key.
+ * @param options.logger - Optional logger for cache errors.
+ * @returns A new asynchronous function with caching behavior.
+ */
+export const useCacheUntil = (fn, cache, { functionName, generateCacheKey, refreshCache = false, logger = silentLogger, }) => {
+    // Use provided key generator or default, adapting the default to use the function's name
+    const _generateCacheKey = generateCacheKey ?? defaultGenerateCacheKey;
+    // Get the function name for the default key generator, handle anonymous functions
+    const _functionName = functionName ?? fn.name ?? 'anonymousFunction';
+    // Map to track expiry timestamps for each cache key
+    const expiryMap = new Map();
+    return async (...args) => {
+        const cacheKey = _generateCacheKey(_functionName, args);
+        const now = Date.now();
+        // Check if cached and not expired.
+        // The cache owns the persisted TTL. When this wrapper is recreated after a
+        // Snap restart, expiryMap is empty, so consult the cache to hydrate a still
+        // valid entry instead of fetching it again.
+        const expiresAt = expiryMap.get(cacheKey);
+        if (!refreshCache && (expiresAt === undefined || now < expiresAt)) {
+            try {
+                const cached = await cache.get(cacheKey);
+                // Check explicitly for undefined, as null or other falsy values might be valid cache results
+                if (cached !== undefined) {
+                    // Type assertion because cache stores Serializable, but we expect TResult
+                    return cached;
+                }
+            }
+            catch (error) {
+                // Log cache get errors but proceed to execute the function
+                logger.error(`Cache get error for key "${cacheKey}":`, error);
+            }
+        }
+        // Execute the original function to get result and new expiry
+        const { result, expiresAt: newExpiresAt } = await fn(...args);
+        // Calculate TTL from expiry timestamp
+        const ttlMilliseconds = Math.max(0, newExpiresAt - now);
+        // Store result in cache with calculated TTL
+        await cache.set(cacheKey, result, ttlMilliseconds).catch((error) => {
+            logger.error(`Cache set error for key "${cacheKey}":`, error);
+        });
+        // Store expiry timestamp
+        expiryMap.set(cacheKey, newExpiresAt);
+        return result;
+    };
+};
+//# sourceMappingURL=useCacheUntil.mjs.map

package/dist/utils/cache/useCacheUntil.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCacheUntil.mjs","sourceRoot":"","sources":["../../../src/utils/cache/useCacheUntil.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,6BAAyB;AACpD,OAAO,EAAE,SAAS,EAAE,2CAAuC;AAI3D;;GAEG;AACH,MAAM,YAAY,GAAG,IAAI,MAAM,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;AAkC5D;;;;;;GAMG;AACH,MAAM,uBAAuB,GAAG,CAC9B,YAAoB,EACpB,IAAoB,EACZ,EAAE,CACV,GAAG,YAAY,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;AAEnF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAI3B,EAA0D,EAC1D,KAA2B,EAC3B,EACE,YAAY,EACZ,gBAAgB,EAChB,YAAY,GAAG,KAAK,EACpB,MAAM,GAAG,YAAY,GACH,EACoB,EAAE;IAC1C,yFAAyF;IACzF,MAAM,iBAAiB,GAAG,gBAAgB,IAAI,uBAAuB,CAAC;IAEtE,kFAAkF;IAClF,MAAM,aAAa,GAAG,YAAY,IAAI,EAAE,CAAC,IAAI,IAAI,mBAAmB,CAAC;IAErE,oDAAoD;IACpD,MAAM,SAAS,GAAG,IAAI,GAAG,EAAkB,CAAC;IAE5C,OAAO,KAAK,EAAE,GAAG,IAAW,EAAoB,EAAE;QAChD,MAAM,QAAQ,GAAG,iBAAiB,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;QACxD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAEvB,mCAAmC;QACnC,2EAA2E;QAC3E,4EAA4E;QAC5E,4CAA4C;QAC5C,MAAM,SAAS,GAAG,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC1C,IAAI,CAAC,YAAY,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,GAAG,GAAG,SAAS,CAAC,EAAE,CAAC;YAClE,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;gBACzC,6FAA6F;gBAC7F,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;oBACzB,0EAA0E;oBAC1E,OAAO,MAAiB,CAAC;gBAC3B,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,2DAA2D;gBAC3D,MAAM,CAAC,KAAK,CAAC,4BAA4B,QAAQ,IAAI,EAAE,KAAK,CAAC,CAAC;YAChE,CAAC;QACH,CAAC;QAED,6DAA6D;QAC7D,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,GAAG,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;QAE9D,sCAAsC;QACtC,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,YAAY,GAAG,GAAG,CAAC,CAAC;QAExD,4CAA4C;QAC5C,MAAM,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YACjE,MAAM,CAAC,KAAK,CAAC,4BAA4B,QAAQ,IAAI,EAAE,KAAK,CAAC,CAAC;QAChE,CAAC,CAAC,CAAC;QAEH,yBAAyB;QACzB,SAAS,CAAC,GAAG,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QAEtC,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC,CAAC","sourcesContent":["import { Logger, LogLevel } from '../logger/Logger';\nimport { serialize } from '../serialization/serialization';\nimport type { Serializable } from '../serialization/types';\nimport type { ICache } from './types';\n\n/**\n * A logger that discards all messages, used when no logger is provided.\n */\nconst silentLogger = new Logger({ level: LogLevel.SILENT });\n\n/**\n * Result type for functions that provide their own expiry time.\n */\nexport type ResultWithExpiry<TResult> = {\n  result: TResult;\n  expiresAt: number; // Unix timestamp in milliseconds\n};\n\n/**\n * Options for configuring the caching behavior of a function with dynamic expiry.\n */\nexport type CacheUntilOptions = {\n  /**\n   * Set this if you want to use a custom function name for the cache key.\n   */\n  functionName?: string;\n  /**\n   * Optional function to generate the cache key for the function call.\n   * Defaults to a function that generates the key based on function name and JSON stringified args separated by colons.\n   */\n  generateCacheKey?: (functionName: string, args: Serializable[]) => string;\n  /**\n   * Whether to refresh the cache.\n   * Defaults to false.\n   */\n  refreshCache?: boolean;\n  /**\n   * Optional logger for cache errors. Defaults to a silent logger.\n   */\n  logger?: Logger;\n};\n\n/**\n * Default function to generate the cache key for a function call.\n *\n * @param functionName - The name of the function.\n * @param args - The arguments of the function call.\n * @returns The cache key.\n */\nconst defaultGenerateCacheKey = (\n  functionName: string,\n  args: Serializable[],\n): string =>\n  `${functionName}:${args.map((arg) => JSON.stringify(serialize(arg))).join(':')}`;\n\n/**\n * Wraps an async function with caching behavior where expiry is determined\n * by the function result itself (dynamic TTL).\n *\n * Unlike `useCache` which uses a fixed TTL, this utility allows the wrapped\n * function to specify when its result expires. This is useful for caching\n * data that has known invalidation points (e.g., blockchain maintenance periods).\n *\n * @template TArgs - Tuple type representing the arguments of the function.\n * @template TResult - The return type of the function, must be Serializable.\n * @param fn - The asynchronous function to wrap. Must return a Promise<ResultWithExpiry<TResult>>.\n * @param cache - The cache instance to use.\n * @param options - The caching options.\n * @param options.refreshCache - Whether to refresh the cache.\n * @param options.functionName - The name of the function.\n * @param options.generateCacheKey - Optional function to generate the cache key.\n * @param options.logger - Optional logger for cache errors.\n * @returns A new asynchronous function with caching behavior.\n */\nexport const useCacheUntil = <\n  TArgs extends Serializable[],\n  TResult extends Serializable,\n>(\n  fn: (...args: TArgs) => Promise<ResultWithExpiry<TResult>>,\n  cache: ICache<Serializable>,\n  {\n    functionName,\n    generateCacheKey,\n    refreshCache = false,\n    logger = silentLogger,\n  }: CacheUntilOptions,\n): ((...args: TArgs) => Promise<TResult>) => {\n  // Use provided key generator or default, adapting the default to use the function's name\n  const _generateCacheKey = generateCacheKey ?? defaultGenerateCacheKey;\n\n  // Get the function name for the default key generator, handle anonymous functions\n  const _functionName = functionName ?? fn.name ?? 'anonymousFunction';\n\n  // Map to track expiry timestamps for each cache key\n  const expiryMap = new Map<string, number>();\n\n  return async (...args: TArgs): Promise<TResult> => {\n    const cacheKey = _generateCacheKey(_functionName, args);\n    const now = Date.now();\n\n    // Check if cached and not expired.\n    // The cache owns the persisted TTL. When this wrapper is recreated after a\n    // Snap restart, expiryMap is empty, so consult the cache to hydrate a still\n    // valid entry instead of fetching it again.\n    const expiresAt = expiryMap.get(cacheKey);\n    if (!refreshCache && (expiresAt === undefined || now < expiresAt)) {\n      try {\n        const cached = await cache.get(cacheKey);\n        // Check explicitly for undefined, as null or other falsy values might be valid cache results\n        if (cached !== undefined) {\n          // Type assertion because cache stores Serializable, but we expect TResult\n          return cached as TResult;\n        }\n      } catch (error) {\n        // Log cache get errors but proceed to execute the function\n        logger.error(`Cache get error for key \"${cacheKey}\":`, error);\n      }\n    }\n\n    // Execute the original function to get result and new expiry\n    const { result, expiresAt: newExpiresAt } = await fn(...args);\n\n    // Calculate TTL from expiry timestamp\n    const ttlMilliseconds = Math.max(0, newExpiresAt - now);\n\n    // Store result in cache with calculated TTL\n    await cache.set(cacheKey, result, ttlMilliseconds).catch((error) => {\n      logger.error(`Cache set error for key \"${cacheKey}\":`, error);\n    });\n\n    // Store expiry timestamp\n    expiryMap.set(cacheKey, newExpiresAt);\n\n    return result;\n  };\n};\n"]}

package/dist/utils/config/BaseConfigProvider.cjs

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseConfigProvider = void 0;
+const parseEnv_1 = require("./parseEnv.cjs");
+/**
+ * A base class that provides the configuration of a snap.
+ *
+ * The environment is parsed and validated once, when the provider is
+ * constructed; an invalid environment throws. Subclasses pass the raw
+ * environment and the struct describing it to the base constructor. Use it
+ * directly when the snap needs no extra config helpers, or extend it to add
+ * them.
+ *
+ * @example
+ * const config = {
+ *   environment: process.env.ENVIRONMENT,
+ * };
+ *
+ * const ConfigStruct = object({
+ *   environment: enums(Object.values(Environment)),
+ * });
+ *
+ * // When no extra helpers are needed, use the base class directly:
+ * const configProvider = new BaseConfigProvider(config, ConfigStruct);
+ * const { environment } = configProvider.config;
+ *
+ * @example
+ * // Otherwise, extend it:
+ * export class ConfigProvider extends BaseConfigProvider<typeof ConfigStruct> {
+ *   constructor() {
+ *     super(config, ConfigStruct);
+ *   }
+ * }
+ *
+ * const configProvider = new ConfigProvider();
+ * const { environment } = configProvider.config;
+ */
+class BaseConfigProvider {
+    #config;
+    /**
+     * Construct the provider, parsing the environment once.
+     *
+     * @param configJson - The configuration JSON for the snap: an object literal referencing
+     * the `process.env` variables consumed by the snap, nested to mirror the
+     * struct where needed.
+     * @param configStruct - The struct describing the configuration, including
+     * coercions from raw strings to typed values.
+     */
+    constructor(configJson, configStruct) {
+        this.#config = (0, parseEnv_1.parseEnv)(configJson, configStruct);
+    }
+    /**
+     * Retrieves configuration of the snap.
+     *
+     * @returns The configuration, built once from the environment.
+     */
+    get config() {
+        return this.#config;
+    }
+}
+exports.BaseConfigProvider = BaseConfigProvider;
+//# sourceMappingURL=BaseConfigProvider.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BaseConfigProvider.cjs","sourceRoot":"","sources":["../../../src/utils/config/BaseConfigProvider.ts"],"names":[],"mappings":";;;AAEA,6CAAsC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAa,kBAAkB;IACpB,OAAO,CAAsB;IAEtC;;;;;;;;OAQG;IACH,YAAY,UAAmC,EAAE,YAA0B;QACzE,IAAI,CAAC,OAAO,GAAG,IAAA,mBAAQ,EAAC,UAAU,EAAE,YAAY,CAAC,CAAC;IACpD,CAAC;IAED;;;;OAIG;IACH,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;CACF;AAxBD,gDAwBC","sourcesContent":["import type { AnyStruct, Infer } from '@metamask/superstruct';\n\nimport { parseEnv } from './parseEnv';\n\n/**\n * A base class that provides the configuration of a snap.\n *\n * The environment is parsed and validated once, when the provider is\n * constructed; an invalid environment throws. Subclasses pass the raw\n * environment and the struct describing it to the base constructor. Use it\n * directly when the snap needs no extra config helpers, or extend it to add\n * them.\n *\n * @example\n * const config = {\n *   environment: process.env.ENVIRONMENT,\n * };\n *\n * const ConfigStruct = object({\n *   environment: enums(Object.values(Environment)),\n * });\n *\n * // When no extra helpers are needed, use the base class directly:\n * const configProvider = new BaseConfigProvider(config, ConfigStruct);\n * const { environment } = configProvider.config;\n *\n * @example\n * // Otherwise, extend it:\n * export class ConfigProvider extends BaseConfigProvider<typeof ConfigStruct> {\n *   constructor() {\n *     super(config, ConfigStruct);\n *   }\n * }\n *\n * const configProvider = new ConfigProvider();\n * const { environment } = configProvider.config;\n */\nexport class BaseConfigProvider<ConfigStruct extends AnyStruct> {\n  readonly #config: Infer<ConfigStruct>;\n\n  /**\n   * Construct the provider, parsing the environment once.\n   *\n   * @param configJson - The configuration JSON for the snap: an object literal referencing\n   * the `process.env` variables consumed by the snap, nested to mirror the\n   * struct where needed.\n   * @param configStruct - The struct describing the configuration, including\n   * coercions from raw strings to typed values.\n   */\n  constructor(configJson: Record<string, unknown>, configStruct: ConfigStruct) {\n    this.#config = parseEnv(configJson, configStruct);\n  }\n\n  /**\n   * Retrieves configuration of the snap.\n   *\n   * @returns The configuration, built once from the environment.\n   */\n  get config(): Infer<ConfigStruct> {\n    return this.#config;\n  }\n}\n"]}

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

@@ -0,0 +1,54 @@
+import type { AnyStruct, Infer } from "@metamask/superstruct";
+/**
+ * A base class that provides the configuration of a snap.
+ *
+ * The environment is parsed and validated once, when the provider is
+ * constructed; an invalid environment throws. Subclasses pass the raw
+ * environment and the struct describing it to the base constructor. Use it
+ * directly when the snap needs no extra config helpers, or extend it to add
+ * them.
+ *
+ * @example
+ * const config = {
+ *   environment: process.env.ENVIRONMENT,
+ * };
+ *
+ * const ConfigStruct = object({
+ *   environment: enums(Object.values(Environment)),
+ * });
+ *
+ * // When no extra helpers are needed, use the base class directly:
+ * const configProvider = new BaseConfigProvider(config, ConfigStruct);
+ * const { environment } = configProvider.config;
+ *
+ * @example
+ * // Otherwise, extend it:
+ * export class ConfigProvider extends BaseConfigProvider<typeof ConfigStruct> {
+ *   constructor() {
+ *     super(config, ConfigStruct);
+ *   }
+ * }
+ *
+ * const configProvider = new ConfigProvider();
+ * const { environment } = configProvider.config;
+ */
+export declare class BaseConfigProvider<ConfigStruct extends AnyStruct> {
+    #private;
+    /**
+     * Construct the provider, parsing the environment once.
+     *
+     * @param configJson - The configuration JSON for the snap: an object literal referencing
+     * the `process.env` variables consumed by the snap, nested to mirror the
+     * struct where needed.
+     * @param configStruct - The struct describing the configuration, including
+     * coercions from raw strings to typed values.
+     */
+    constructor(configJson: Record<string, unknown>, configStruct: ConfigStruct);
+    /**
+     * Retrieves configuration of the snap.
+     *
+     * @returns The configuration, built once from the environment.
+     */
+    get config(): Infer<ConfigStruct>;
+}
+//# sourceMappingURL=BaseConfigProvider.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BaseConfigProvider.d.cts","sourceRoot":"","sources":["../../../src/utils/config/BaseConfigProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,8BAA8B;AAI9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,kBAAkB,CAAC,YAAY,SAAS,SAAS;;IAG5D;;;;;;;;OAQG;gBACS,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,EAAE,YAAY;IAI3E;;;;OAIG;IACH,IAAI,MAAM,IAAI,KAAK,CAAC,YAAY,CAAC,CAEhC;CACF"}

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

@@ -0,0 +1,54 @@
+import type { AnyStruct, Infer } from "@metamask/superstruct";
+/**
+ * A base class that provides the configuration of a snap.
+ *
+ * The environment is parsed and validated once, when the provider is
+ * constructed; an invalid environment throws. Subclasses pass the raw
+ * environment and the struct describing it to the base constructor. Use it
+ * directly when the snap needs no extra config helpers, or extend it to add
+ * them.
+ *
+ * @example
+ * const config = {
+ *   environment: process.env.ENVIRONMENT,
+ * };
+ *
+ * const ConfigStruct = object({
+ *   environment: enums(Object.values(Environment)),
+ * });
+ *
+ * // When no extra helpers are needed, use the base class directly:
+ * const configProvider = new BaseConfigProvider(config, ConfigStruct);
+ * const { environment } = configProvider.config;
+ *
+ * @example
+ * // Otherwise, extend it:
+ * export class ConfigProvider extends BaseConfigProvider<typeof ConfigStruct> {
+ *   constructor() {
+ *     super(config, ConfigStruct);
+ *   }
+ * }
+ *
+ * const configProvider = new ConfigProvider();
+ * const { environment } = configProvider.config;
+ */
+export declare class BaseConfigProvider<ConfigStruct extends AnyStruct> {
+    #private;
+    /**
+     * Construct the provider, parsing the environment once.
+     *
+     * @param configJson - The configuration JSON for the snap: an object literal referencing
+     * the `process.env` variables consumed by the snap, nested to mirror the
+     * struct where needed.
+     * @param configStruct - The struct describing the configuration, including
+     * coercions from raw strings to typed values.
+     */
+    constructor(configJson: Record<string, unknown>, configStruct: ConfigStruct);
+    /**
+     * Retrieves configuration of the snap.
+     *
+     * @returns The configuration, built once from the environment.
+     */
+    get config(): Infer<ConfigStruct>;
+}
+//# sourceMappingURL=BaseConfigProvider.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BaseConfigProvider.d.mts","sourceRoot":"","sources":["../../../src/utils/config/BaseConfigProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,8BAA8B;AAI9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,kBAAkB,CAAC,YAAY,SAAS,SAAS;;IAG5D;;;;;;;;OAQG;gBACS,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,EAAE,YAAY;IAI3E;;;;OAIG;IACH,IAAI,MAAM,IAAI,KAAK,CAAC,YAAY,CAAC,CAEhC;CACF"}

package/dist/utils/config/BaseConfigProvider.mjs

@@ -0,0 +1,58 @@
+import { parseEnv } from "./parseEnv.mjs";
+/**
+ * A base class that provides the configuration of a snap.
+ *
+ * The environment is parsed and validated once, when the provider is
+ * constructed; an invalid environment throws. Subclasses pass the raw
+ * environment and the struct describing it to the base constructor. Use it
+ * directly when the snap needs no extra config helpers, or extend it to add
+ * them.
+ *
+ * @example
+ * const config = {
+ *   environment: process.env.ENVIRONMENT,
+ * };
+ *
+ * const ConfigStruct = object({
+ *   environment: enums(Object.values(Environment)),
+ * });
+ *
+ * // When no extra helpers are needed, use the base class directly:
+ * const configProvider = new BaseConfigProvider(config, ConfigStruct);
+ * const { environment } = configProvider.config;
+ *
+ * @example
+ * // Otherwise, extend it:
+ * export class ConfigProvider extends BaseConfigProvider<typeof ConfigStruct> {
+ *   constructor() {
+ *     super(config, ConfigStruct);
+ *   }
+ * }
+ *
+ * const configProvider = new ConfigProvider();
+ * const { environment } = configProvider.config;
+ */
+export class BaseConfigProvider {
+    #config;
+    /**
+     * Construct the provider, parsing the environment once.
+     *
+     * @param configJson - The configuration JSON for the snap: an object literal referencing
+     * the `process.env` variables consumed by the snap, nested to mirror the
+     * struct where needed.
+     * @param configStruct - The struct describing the configuration, including
+     * coercions from raw strings to typed values.
+     */
+    constructor(configJson, configStruct) {
+        this.#config = parseEnv(configJson, configStruct);
+    }
+    /**
+     * Retrieves configuration of the snap.
+     *
+     * @returns The configuration, built once from the environment.
+     */
+    get config() {
+        return this.#config;
+    }
+}
+//# sourceMappingURL=BaseConfigProvider.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BaseConfigProvider.mjs","sourceRoot":"","sources":["../../../src/utils/config/BaseConfigProvider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,uBAAmB;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,OAAO,kBAAkB;IACpB,OAAO,CAAsB;IAEtC;;;;;;;;OAQG;IACH,YAAY,UAAmC,EAAE,YAA0B;QACzE,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;IACpD,CAAC;IAED;;;;OAIG;IACH,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;CACF","sourcesContent":["import type { AnyStruct, Infer } from '@metamask/superstruct';\n\nimport { parseEnv } from './parseEnv';\n\n/**\n * A base class that provides the configuration of a snap.\n *\n * The environment is parsed and validated once, when the provider is\n * constructed; an invalid environment throws. Subclasses pass the raw\n * environment and the struct describing it to the base constructor. Use it\n * directly when the snap needs no extra config helpers, or extend it to add\n * them.\n *\n * @example\n * const config = {\n *   environment: process.env.ENVIRONMENT,\n * };\n *\n * const ConfigStruct = object({\n *   environment: enums(Object.values(Environment)),\n * });\n *\n * // When no extra helpers are needed, use the base class directly:\n * const configProvider = new BaseConfigProvider(config, ConfigStruct);\n * const { environment } = configProvider.config;\n *\n * @example\n * // Otherwise, extend it:\n * export class ConfigProvider extends BaseConfigProvider<typeof ConfigStruct> {\n *   constructor() {\n *     super(config, ConfigStruct);\n *   }\n * }\n *\n * const configProvider = new ConfigProvider();\n * const { environment } = configProvider.config;\n */\nexport class BaseConfigProvider<ConfigStruct extends AnyStruct> {\n  readonly #config: Infer<ConfigStruct>;\n\n  /**\n   * Construct the provider, parsing the environment once.\n   *\n   * @param configJson - The configuration JSON for the snap: an object literal referencing\n   * the `process.env` variables consumed by the snap, nested to mirror the\n   * struct where needed.\n   * @param configStruct - The struct describing the configuration, including\n   * coercions from raw strings to typed values.\n   */\n  constructor(configJson: Record<string, unknown>, configStruct: ConfigStruct) {\n    this.#config = parseEnv(configJson, configStruct);\n  }\n\n  /**\n   * Retrieves configuration of the snap.\n   *\n   * @returns The configuration, built once from the environment.\n   */\n  get config(): Infer<ConfigStruct> {\n    return this.#config;\n  }\n}\n"]}

package/dist/utils/config/envStructs.cjs

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFloatStruct = exports.parseIntegerStruct = exports.defaultedUrlStruct = exports.commaSeparatedListOf = exports.emptyToUndefined = void 0;
+const superstruct_1 = require("@metamask/superstruct");
+const urlStruct_1 = require("../urlStruct/urlStruct.cjs");
+/**
+ * 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);
+ */
+const emptyToUndefined = (item) => (0, superstruct_1.coerce)((0, superstruct_1.optional)(item), (0, superstruct_1.string)(), (value) => value === '' ? undefined : value);
+exports.emptyToUndefined = emptyToUndefined;
+/**
+ * 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);
+ */
+const commaSeparatedListOf = (item) => (0, superstruct_1.coerce)((0, superstruct_1.array)(item), (0, superstruct_1.string)(), (value) => value.split(','));
+exports.commaSeparatedListOf = commaSeparatedListOf;
+/**
+ * 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');
+ */
+const defaultedUrlStruct = (fallback) => (0, superstruct_1.coerce)((0, superstruct_1.defaulted)(urlStruct_1.UrlStruct, fallback), (0, superstruct_1.string)(), (value) => {
+    const trimmed = value.trim();
+    return trimmed === '' ? undefined : trimmed;
+});
+exports.defaultedUrlStruct = defaultedUrlStruct;
+/**
+ * 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.
+ */
+const parseIntegerStruct = (minValue, defaultValue) => (0, superstruct_1.coerce)((0, superstruct_1.defaulted)((0, superstruct_1.min)((0, superstruct_1.number)(), minValue), defaultValue), (0, superstruct_1.string)(), (value) => (value === '' ? undefined : parseInt(value, 10)));
+exports.parseIntegerStruct = parseIntegerStruct;
+/**
+ * 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.
+ */
+const parseFloatStruct = (minValue, defaultValue) => (0, superstruct_1.coerce)((0, superstruct_1.defaulted)((0, superstruct_1.min)((0, superstruct_1.number)(), minValue), defaultValue), (0, superstruct_1.string)(), (value) => (value === '' ? undefined : parseFloat(value)));
+exports.parseFloatStruct = parseFloatStruct;
+//# sourceMappingURL=envStructs.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"envStructs.cjs","sourceRoot":"","sources":["../../../src/utils/config/envStructs.ts"],"names":[],"mappings":";;;AACA,uDAQ+B;AAE/B,0DAAmD;AAEnD;;;;;;;;;;GAUG;AACI,MAAM,gBAAgB,GAAG,CAC9B,IAAkB,EACQ,EAAE,CAC5B,IAAA,oBAAM,EAAC,IAAA,sBAAQ,EAAC,IAAI,CAAC,EAAE,IAAA,oBAAM,GAAE,EAAE,CAAC,KAAa,EAAE,EAAE,CACjD,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CACjC,CAAC;AALS,QAAA,gBAAgB,oBAKzB;AAEJ;;;;;;;;;;GAUG;AACI,MAAM,oBAAoB,GAAG,CAClC,IAAkB,EACF,EAAE,CAClB,IAAA,oBAAM,EAAC,IAAA,mBAAK,EAAC,IAAI,CAAC,EAAE,IAAA,oBAAM,GAAE,EAAE,CAAC,KAAa,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;AAHxD,QAAA,oBAAoB,wBAGoC;AAErE;;;;;;;;;;;GAWG;AACI,MAAM,kBAAkB,GAAG,CAAC,QAAgB,EAAkB,EAAE,CACrE,IAAA,oBAAM,EAAC,IAAA,uBAAS,EAAC,qBAAS,EAAE,QAAQ,CAAC,EAAE,IAAA,oBAAM,GAAE,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;AAJQ,QAAA,kBAAkB,sBAI1B;AAEL;;;;;;;GAOG;AACI,MAAM,kBAAkB,GAAG,CAChC,QAAgB,EAChB,YAAoB,EACJ,EAAE,CAClB,IAAA,oBAAM,EACJ,IAAA,uBAAS,EAAC,IAAA,iBAAG,EAAC,IAAA,oBAAM,GAAE,EAAE,QAAQ,CAAC,EAAE,YAAY,CAAC,EAChD,IAAA,oBAAM,GAAE,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;AARS,QAAA,kBAAkB,sBAQ3B;AAEJ;;;;;;;GAOG;AACI,MAAM,gBAAgB,GAAG,CAC9B,QAAgB,EAChB,YAAoB,EACJ,EAAE,CAClB,IAAA,oBAAM,EACJ,IAAA,uBAAS,EAAC,IAAA,iBAAG,EAAC,IAAA,oBAAM,GAAE,EAAE,QAAQ,CAAC,EAAE,YAAY,CAAC,EAChD,IAAA,oBAAM,GAAE,EACR,CAAC,KAAa,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAClE,CAAC;AARS,QAAA,gBAAgB,oBAQzB","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/envStructs.d.cts

@@ -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.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"envStructs.d.cts","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"}