@metamask/smart-transactions-controller 21.1.0 → 22.0.0

package/dist/featureFlags/feature-flags.cjs

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSmartTransactionsFeatureFlagsForChain = exports.getSmartTransactionsFeatureFlags = exports.processSmartTransactionsFeatureFlags = exports.normalizeChainId = void 0;
+const utils_1 = require("@metamask/utils");
+const constants_1 = require("../constants.cjs");
+const validators_1 = require("./validators.cjs");
+/**
+ * Normalizes a chain ID to hex format for EVM chains.
+ * - CAIP-2 EVM format (eip155:X) is converted to hex (0xY)
+ * - Hex format is returned as-is
+ * - Non-EVM CAIP-2 formats are returned as-is (exact match)
+ * - Invalid eip155 formats (non-numeric reference) are returned as-is
+ * - This is used because the current STX chains are EVM and declared as hex chain IDs in the existing flag.
+ *
+ * @param chainId - The chain ID in any supported format
+ * @returns Normalized chain ID (hex for EVM, original for non-EVM)
+ * @example
+ * ```ts
+ * normalizeChainId('0x1')           // → '0x1'
+ * normalizeChainId('eip155:1')      // → '0x1'
+ * normalizeChainId('eip155:137')    // → '0x89'
+ * normalizeChainId('solana:...')    // → 'solana:...' (unchanged)
+ * normalizeChainId('eip155:abc')    // → 'eip155:abc' (invalid, unchanged)
+ * ```
+ */
+function normalizeChainId(chainId) {
+    // If it's already hex or not a valid CAIP chain ID, return as-is
+    if (!(0, utils_1.isCaipChainId)(chainId)) {
+        return chainId;
+    }
+    const { namespace, reference } = (0, utils_1.parseCaipChainId)(chainId);
+    // Only normalize EVM CAIP-2 chains with valid numeric references to hex
+    if (namespace === utils_1.KnownCaipNamespace.Eip155) {
+        const decimal = parseInt(reference, 10);
+        // If reference is not a valid number, return as-is
+        if (Number.isNaN(decimal)) {
+            return chainId;
+        }
+        return (0, utils_1.numberToHex)(decimal);
+    }
+    // Non-EVM CAIP chains remain unchanged
+    return chainId;
+}
+exports.normalizeChainId = normalizeChainId;
+/**
+ * Processes raw feature flags data and returns a validated configuration.
+ * Invalid chain configs are silently removed. Error reporting is handled by
+ * the SmartTransactionsController via ErrorReportingService.
+ *
+ * @param rawFeatureFlags - The raw feature flags data from the remote feature flag controller
+ * @returns The validated feature flags configuration (partial if some chains were invalid)
+ */
+function processSmartTransactionsFeatureFlags(rawFeatureFlags) {
+    const { config } = (0, validators_1.validateSmartTransactionsFeatureFlags)(rawFeatureFlags);
+    // Return config if it has any valid data, otherwise return defaults
+    if (Object.keys(config).length > 0) {
+        return config;
+    }
+    return constants_1.DEFAULT_DISABLED_SMART_TRANSACTIONS_FEATURE_FLAGS;
+}
+exports.processSmartTransactionsFeatureFlags = processSmartTransactionsFeatureFlags;
+/**
+ * Gets the smart transactions feature flags from the remote feature flag controller.
+ *
+ * @param messenger - Any messenger with access to RemoteFeatureFlagController:getState
+ * @returns The smart transactions feature flags configuration
+ * @example
+ * ```ts
+ * const featureFlags = getSmartTransactionsFeatureFlags(messenger);
+ * const chainConfig = featureFlags['0x1'] ?? featureFlags.default;
+ * ```
+ */
+function getSmartTransactionsFeatureFlags(messenger) {
+    var _a;
+    const remoteFeatureFlagControllerState = messenger.call('RemoteFeatureFlagController:getState');
+    const rawSmartTransactionsNetworks = (_a = remoteFeatureFlagControllerState === null || remoteFeatureFlagControllerState === void 0 ? void 0 : remoteFeatureFlagControllerState.remoteFeatureFlags) === null || _a === void 0 ? void 0 : _a.smartTransactionsNetworks;
+    return processSmartTransactionsFeatureFlags(rawSmartTransactionsNetworks);
+}
+exports.getSmartTransactionsFeatureFlags = getSmartTransactionsFeatureFlags;
+/**
+ * Gets the merged feature flags configuration for a specific chain.
+ * Chain-specific configuration takes precedence over default configuration.
+ *
+ * For EVM chains, the chain ID is normalized to hex format before lookup.
+ * This means both '0x1' and 'eip155:1' will resolve to the same configuration.
+ * Non-EVM chains (e.g., Solana, Bitcoin) use exact match.
+ *
+ * @param featureFlags - The full feature flags configuration
+ * @param chainId - The chain ID to get configuration for.
+ * Supports both hex (e.g., "0x1") and CAIP-2 format (e.g., "eip155:1", "solana:...")
+ * @returns The merged configuration for the specified chain
+ * @example
+ * ```ts
+ * const featureFlags = getSmartTransactionsFeatureFlags(messenger);
+ *
+ * // Both resolve to the same config (normalized to 0x1)
+ * const chainConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, '0x1');
+ * const sameConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, 'eip155:1');
+ *
+ * // Non-EVM uses exact match
+ * const solanaConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp');
+ *
+ * if (chainConfig.extensionActive) {
+ *   // Smart transactions are enabled for this chain
+ * }
+ * ```
+ */
+function getSmartTransactionsFeatureFlagsForChain(featureFlags, chainId) {
+    var _a;
+    const normalizedChainId = normalizeChainId(chainId);
+    const defaultRemoteConfig = (_a = featureFlags.default) !== null && _a !== void 0 ? _a : {};
+    const chainRemoteConfig = featureFlags[normalizedChainId];
+    if (chainRemoteConfig === undefined) {
+        return constants_1.DEFAULT_DISABLED_SMART_TRANSACTIONS_FEATURE_FLAGS.default;
+    }
+    return Object.assign(Object.assign({}, defaultRemoteConfig), chainRemoteConfig);
+}
+exports.getSmartTransactionsFeatureFlagsForChain = getSmartTransactionsFeatureFlagsForChain;
+//# sourceMappingURL=feature-flags.cjs.map

package/dist/featureFlags/feature-flags.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flags.cjs","sourceRoot":"","sources":["../../src/featureFlags/feature-flags.ts"],"names":[],"mappings":";;;AAEA,2CAKyB;AAEzB,gDAAiF;AAKjF,iDAAqE;AAErE;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,gBAAgB,CAC9B,OAA0B;IAE1B,iEAAiE;IACjE,IAAI,CAAC,IAAA,qBAAa,EAAC,OAAO,CAAC,EAAE;QAC3B,OAAO,OAAO,CAAC;KAChB;IAED,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,IAAA,wBAAgB,EAAC,OAAO,CAAC,CAAC;IAE3D,wEAAwE;IACxE,IAAI,SAAS,KAAK,0BAAkB,CAAC,MAAM,EAAE;QAC3C,MAAM,OAAO,GAAG,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;QACxC,mDAAmD;QACnD,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE;YACzB,OAAO,OAAO,CAAC;SAChB;QACD,OAAO,IAAA,mBAAW,EAAC,OAAO,CAAC,CAAC;KAC7B;IAED,uCAAuC;IACvC,OAAO,OAAO,CAAC;AACjB,CAAC;AAtBD,4CAsBC;AAED;;;;;;;GAOG;AACH,SAAgB,oCAAoC,CAClD,eAAwB;IAExB,MAAM,EAAE,MAAM,EAAE,GAAG,IAAA,kDAAqC,EAAC,eAAe,CAAC,CAAC;IAE1E,oEAAoE;IACpE,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;QAClC,OAAO,MAAM,CAAC;KACf;IAED,OAAO,6DAAiD,CAAC;AAC3D,CAAC;AAXD,oFAWC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,gCAAgC,CAM9C,SAAY;;IACZ,MAAM,gCAAgC,GAAG,SAAS,CAAC,IAAI,CACrD,sCAAsC,CACvC,CAAC;IAEF,MAAM,4BAA4B,GAChC,MAAA,gCAAgC,aAAhC,gCAAgC,uBAAhC,gCAAgC,CAAE,kBAAkB,0CAChD,yBAAyB,CAAC;IAEhC,OAAO,oCAAoC,CAAC,4BAA4B,CAAC,CAAC;AAC5E,CAAC;AAhBD,4EAgBC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,SAAgB,wCAAwC,CACtD,YAAiD,EACjD,OAA0B;;IAE1B,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACpD,MAAM,mBAAmB,GAAG,MAAA,YAAY,CAAC,OAAO,mCAAI,EAAE,CAAC;IACvD,MAAM,iBAAiB,GAAG,YAAY,CAAC,iBAAiB,CAAC,CAAC;IAE1D,IAAI,iBAAiB,KAAK,SAAS,EAAE;QACnC,OAAO,6DAAiD,CAAC,OAAO,CAAC;KAClE;IAED,uCACK,mBAAmB,GACnB,iBAAiB,EACpB;AACJ,CAAC;AAhBD,4FAgBC","sourcesContent":["import type { RemoteFeatureFlagControllerState } from '@metamask/remote-feature-flag-controller';\nimport type { CaipChainId, Hex } from '@metamask/utils';\nimport {\n  isCaipChainId,\n  KnownCaipNamespace,\n  numberToHex,\n  parseCaipChainId,\n} from '@metamask/utils';\n\nimport { DEFAULT_DISABLED_SMART_TRANSACTIONS_FEATURE_FLAGS } from '../constants';\nimport type {\n  SmartTransactionsFeatureFlagsConfig,\n  SmartTransactionsNetworkConfig,\n} from '../types';\nimport { validateSmartTransactionsFeatureFlags } from './validators';\n\n/**\n * Normalizes a chain ID to hex format for EVM chains.\n * - CAIP-2 EVM format (eip155:X) is converted to hex (0xY)\n * - Hex format is returned as-is\n * - Non-EVM CAIP-2 formats are returned as-is (exact match)\n * - Invalid eip155 formats (non-numeric reference) are returned as-is\n * - This is used because the current STX chains are EVM and declared as hex chain IDs in the existing flag.\n *\n * @param chainId - The chain ID in any supported format\n * @returns Normalized chain ID (hex for EVM, original for non-EVM)\n * @example\n * ```ts\n * normalizeChainId('0x1')           // → '0x1'\n * normalizeChainId('eip155:1')      // → '0x1'\n * normalizeChainId('eip155:137')    // → '0x89'\n * normalizeChainId('solana:...')    // → 'solana:...' (unchanged)\n * normalizeChainId('eip155:abc')    // → 'eip155:abc' (invalid, unchanged)\n * ```\n */\nexport function normalizeChainId(\n  chainId: Hex | CaipChainId,\n): Hex | CaipChainId {\n  // If it's already hex or not a valid CAIP chain ID, return as-is\n  if (!isCaipChainId(chainId)) {\n    return chainId;\n  }\n\n  const { namespace, reference } = parseCaipChainId(chainId);\n\n  // Only normalize EVM CAIP-2 chains with valid numeric references to hex\n  if (namespace === KnownCaipNamespace.Eip155) {\n    const decimal = parseInt(reference, 10);\n    // If reference is not a valid number, return as-is\n    if (Number.isNaN(decimal)) {\n      return chainId;\n    }\n    return numberToHex(decimal);\n  }\n\n  // Non-EVM CAIP chains remain unchanged\n  return chainId;\n}\n\n/**\n * Processes raw feature flags data and returns a validated configuration.\n * Invalid chain configs are silently removed. Error reporting is handled by\n * the SmartTransactionsController via ErrorReportingService.\n *\n * @param rawFeatureFlags - The raw feature flags data from the remote feature flag controller\n * @returns The validated feature flags configuration (partial if some chains were invalid)\n */\nexport function processSmartTransactionsFeatureFlags(\n  rawFeatureFlags: unknown,\n): SmartTransactionsFeatureFlagsConfig {\n  const { config } = validateSmartTransactionsFeatureFlags(rawFeatureFlags);\n\n  // Return config if it has any valid data, otherwise return defaults\n  if (Object.keys(config).length > 0) {\n    return config;\n  }\n\n  return DEFAULT_DISABLED_SMART_TRANSACTIONS_FEATURE_FLAGS;\n}\n\n/**\n * Gets the smart transactions feature flags from the remote feature flag controller.\n *\n * @param messenger - Any messenger with access to RemoteFeatureFlagController:getState\n * @returns The smart transactions feature flags configuration\n * @example\n * ```ts\n * const featureFlags = getSmartTransactionsFeatureFlags(messenger);\n * const chainConfig = featureFlags['0x1'] ?? featureFlags.default;\n * ```\n */\nexport function getSmartTransactionsFeatureFlags<\n  T extends {\n    call(\n      action: 'RemoteFeatureFlagController:getState',\n    ): RemoteFeatureFlagControllerState;\n  },\n>(messenger: T): SmartTransactionsFeatureFlagsConfig {\n  const remoteFeatureFlagControllerState = messenger.call(\n    'RemoteFeatureFlagController:getState',\n  );\n\n  const rawSmartTransactionsNetworks =\n    remoteFeatureFlagControllerState?.remoteFeatureFlags\n      ?.smartTransactionsNetworks;\n\n  return processSmartTransactionsFeatureFlags(rawSmartTransactionsNetworks);\n}\n\n/**\n * Gets the merged feature flags configuration for a specific chain.\n * Chain-specific configuration takes precedence over default configuration.\n *\n * For EVM chains, the chain ID is normalized to hex format before lookup.\n * This means both '0x1' and 'eip155:1' will resolve to the same configuration.\n * Non-EVM chains (e.g., Solana, Bitcoin) use exact match.\n *\n * @param featureFlags - The full feature flags configuration\n * @param chainId - The chain ID to get configuration for.\n * Supports both hex (e.g., \"0x1\") and CAIP-2 format (e.g., \"eip155:1\", \"solana:...\")\n * @returns The merged configuration for the specified chain\n * @example\n * ```ts\n * const featureFlags = getSmartTransactionsFeatureFlags(messenger);\n *\n * // Both resolve to the same config (normalized to 0x1)\n * const chainConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, '0x1');\n * const sameConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, 'eip155:1');\n *\n * // Non-EVM uses exact match\n * const solanaConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp');\n *\n * if (chainConfig.extensionActive) {\n *   // Smart transactions are enabled for this chain\n * }\n * ```\n */\nexport function getSmartTransactionsFeatureFlagsForChain(\n  featureFlags: SmartTransactionsFeatureFlagsConfig,\n  chainId: Hex | CaipChainId,\n): SmartTransactionsNetworkConfig {\n  const normalizedChainId = normalizeChainId(chainId);\n  const defaultRemoteConfig = featureFlags.default ?? {};\n  const chainRemoteConfig = featureFlags[normalizedChainId];\n\n  if (chainRemoteConfig === undefined) {\n    return DEFAULT_DISABLED_SMART_TRANSACTIONS_FEATURE_FLAGS.default;\n  }\n\n  return {\n    ...defaultRemoteConfig,\n    ...chainRemoteConfig,\n  };\n}\n"]}

package/dist/featureFlags/feature-flags.d.cts

@@ -0,0 +1,76 @@
+import type { RemoteFeatureFlagControllerState } from "@metamask/remote-feature-flag-controller";
+import type { CaipChainId, Hex } from "@metamask/utils";
+import type { SmartTransactionsFeatureFlagsConfig, SmartTransactionsNetworkConfig } from "../types.cjs";
+/**
+ * Normalizes a chain ID to hex format for EVM chains.
+ * - CAIP-2 EVM format (eip155:X) is converted to hex (0xY)
+ * - Hex format is returned as-is
+ * - Non-EVM CAIP-2 formats are returned as-is (exact match)
+ * - Invalid eip155 formats (non-numeric reference) are returned as-is
+ * - This is used because the current STX chains are EVM and declared as hex chain IDs in the existing flag.
+ *
+ * @param chainId - The chain ID in any supported format
+ * @returns Normalized chain ID (hex for EVM, original for non-EVM)
+ * @example
+ * ```ts
+ * normalizeChainId('0x1')           // → '0x1'
+ * normalizeChainId('eip155:1')      // → '0x1'
+ * normalizeChainId('eip155:137')    // → '0x89'
+ * normalizeChainId('solana:...')    // → 'solana:...' (unchanged)
+ * normalizeChainId('eip155:abc')    // → 'eip155:abc' (invalid, unchanged)
+ * ```
+ */
+export declare function normalizeChainId(chainId: Hex | CaipChainId): Hex | CaipChainId;
+/**
+ * Processes raw feature flags data and returns a validated configuration.
+ * Invalid chain configs are silently removed. Error reporting is handled by
+ * the SmartTransactionsController via ErrorReportingService.
+ *
+ * @param rawFeatureFlags - The raw feature flags data from the remote feature flag controller
+ * @returns The validated feature flags configuration (partial if some chains were invalid)
+ */
+export declare function processSmartTransactionsFeatureFlags(rawFeatureFlags: unknown): SmartTransactionsFeatureFlagsConfig;
+/**
+ * Gets the smart transactions feature flags from the remote feature flag controller.
+ *
+ * @param messenger - Any messenger with access to RemoteFeatureFlagController:getState
+ * @returns The smart transactions feature flags configuration
+ * @example
+ * ```ts
+ * const featureFlags = getSmartTransactionsFeatureFlags(messenger);
+ * const chainConfig = featureFlags['0x1'] ?? featureFlags.default;
+ * ```
+ */
+export declare function getSmartTransactionsFeatureFlags<T extends {
+    call(action: 'RemoteFeatureFlagController:getState'): RemoteFeatureFlagControllerState;
+}>(messenger: T): SmartTransactionsFeatureFlagsConfig;
+/**
+ * Gets the merged feature flags configuration for a specific chain.
+ * Chain-specific configuration takes precedence over default configuration.
+ *
+ * For EVM chains, the chain ID is normalized to hex format before lookup.
+ * This means both '0x1' and 'eip155:1' will resolve to the same configuration.
+ * Non-EVM chains (e.g., Solana, Bitcoin) use exact match.
+ *
+ * @param featureFlags - The full feature flags configuration
+ * @param chainId - The chain ID to get configuration for.
+ * Supports both hex (e.g., "0x1") and CAIP-2 format (e.g., "eip155:1", "solana:...")
+ * @returns The merged configuration for the specified chain
+ * @example
+ * ```ts
+ * const featureFlags = getSmartTransactionsFeatureFlags(messenger);
+ *
+ * // Both resolve to the same config (normalized to 0x1)
+ * const chainConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, '0x1');
+ * const sameConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, 'eip155:1');
+ *
+ * // Non-EVM uses exact match
+ * const solanaConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp');
+ *
+ * if (chainConfig.extensionActive) {
+ *   // Smart transactions are enabled for this chain
+ * }
+ * ```
+ */
+export declare function getSmartTransactionsFeatureFlagsForChain(featureFlags: SmartTransactionsFeatureFlagsConfig, chainId: Hex | CaipChainId): SmartTransactionsNetworkConfig;
+//# sourceMappingURL=feature-flags.d.cts.map

package/dist/featureFlags/feature-flags.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flags.d.cts","sourceRoot":"","sources":["../../src/featureFlags/feature-flags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gCAAgC,EAAE,iDAAiD;AACjG,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,wBAAwB;AASxD,OAAO,KAAK,EACV,mCAAmC,EACnC,8BAA8B,EAC/B,qBAAiB;AAGlB;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,GAAG,GAAG,WAAW,GACzB,GAAG,GAAG,WAAW,CAoBnB;AAED;;;;;;;GAOG;AACH,wBAAgB,oCAAoC,CAClD,eAAe,EAAE,OAAO,GACvB,mCAAmC,CASrC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAC9C,CAAC,SAAS;IACR,IAAI,CACF,MAAM,EAAE,sCAAsC,GAC7C,gCAAgC,CAAC;CACrC,EACD,SAAS,EAAE,CAAC,GAAG,mCAAmC,CAUnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,wCAAwC,CACtD,YAAY,EAAE,mCAAmC,EACjD,OAAO,EAAE,GAAG,GAAG,WAAW,GACzB,8BAA8B,CAahC"}

package/dist/featureFlags/feature-flags.d.mts

@@ -0,0 +1,76 @@
+import type { RemoteFeatureFlagControllerState } from "@metamask/remote-feature-flag-controller";
+import type { CaipChainId, Hex } from "@metamask/utils";
+import type { SmartTransactionsFeatureFlagsConfig, SmartTransactionsNetworkConfig } from "../types.mjs";
+/**
+ * Normalizes a chain ID to hex format for EVM chains.
+ * - CAIP-2 EVM format (eip155:X) is converted to hex (0xY)
+ * - Hex format is returned as-is
+ * - Non-EVM CAIP-2 formats are returned as-is (exact match)
+ * - Invalid eip155 formats (non-numeric reference) are returned as-is
+ * - This is used because the current STX chains are EVM and declared as hex chain IDs in the existing flag.
+ *
+ * @param chainId - The chain ID in any supported format
+ * @returns Normalized chain ID (hex for EVM, original for non-EVM)
+ * @example
+ * ```ts
+ * normalizeChainId('0x1')           // → '0x1'
+ * normalizeChainId('eip155:1')      // → '0x1'
+ * normalizeChainId('eip155:137')    // → '0x89'
+ * normalizeChainId('solana:...')    // → 'solana:...' (unchanged)
+ * normalizeChainId('eip155:abc')    // → 'eip155:abc' (invalid, unchanged)
+ * ```
+ */
+export declare function normalizeChainId(chainId: Hex | CaipChainId): Hex | CaipChainId;
+/**
+ * Processes raw feature flags data and returns a validated configuration.
+ * Invalid chain configs are silently removed. Error reporting is handled by
+ * the SmartTransactionsController via ErrorReportingService.
+ *
+ * @param rawFeatureFlags - The raw feature flags data from the remote feature flag controller
+ * @returns The validated feature flags configuration (partial if some chains were invalid)
+ */
+export declare function processSmartTransactionsFeatureFlags(rawFeatureFlags: unknown): SmartTransactionsFeatureFlagsConfig;
+/**
+ * Gets the smart transactions feature flags from the remote feature flag controller.
+ *
+ * @param messenger - Any messenger with access to RemoteFeatureFlagController:getState
+ * @returns The smart transactions feature flags configuration
+ * @example
+ * ```ts
+ * const featureFlags = getSmartTransactionsFeatureFlags(messenger);
+ * const chainConfig = featureFlags['0x1'] ?? featureFlags.default;
+ * ```
+ */
+export declare function getSmartTransactionsFeatureFlags<T extends {
+    call(action: 'RemoteFeatureFlagController:getState'): RemoteFeatureFlagControllerState;
+}>(messenger: T): SmartTransactionsFeatureFlagsConfig;
+/**
+ * Gets the merged feature flags configuration for a specific chain.
+ * Chain-specific configuration takes precedence over default configuration.
+ *
+ * For EVM chains, the chain ID is normalized to hex format before lookup.
+ * This means both '0x1' and 'eip155:1' will resolve to the same configuration.
+ * Non-EVM chains (e.g., Solana, Bitcoin) use exact match.
+ *
+ * @param featureFlags - The full feature flags configuration
+ * @param chainId - The chain ID to get configuration for.
+ * Supports both hex (e.g., "0x1") and CAIP-2 format (e.g., "eip155:1", "solana:...")
+ * @returns The merged configuration for the specified chain
+ * @example
+ * ```ts
+ * const featureFlags = getSmartTransactionsFeatureFlags(messenger);
+ *
+ * // Both resolve to the same config (normalized to 0x1)
+ * const chainConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, '0x1');
+ * const sameConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, 'eip155:1');
+ *
+ * // Non-EVM uses exact match
+ * const solanaConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp');
+ *
+ * if (chainConfig.extensionActive) {
+ *   // Smart transactions are enabled for this chain
+ * }
+ * ```
+ */
+export declare function getSmartTransactionsFeatureFlagsForChain(featureFlags: SmartTransactionsFeatureFlagsConfig, chainId: Hex | CaipChainId): SmartTransactionsNetworkConfig;
+//# sourceMappingURL=feature-flags.d.mts.map

package/dist/featureFlags/feature-flags.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flags.d.mts","sourceRoot":"","sources":["../../src/featureFlags/feature-flags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gCAAgC,EAAE,iDAAiD;AACjG,OAAO,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,wBAAwB;AASxD,OAAO,KAAK,EACV,mCAAmC,EACnC,8BAA8B,EAC/B,qBAAiB;AAGlB;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,GAAG,GAAG,WAAW,GACzB,GAAG,GAAG,WAAW,CAoBnB;AAED;;;;;;;GAOG;AACH,wBAAgB,oCAAoC,CAClD,eAAe,EAAE,OAAO,GACvB,mCAAmC,CASrC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAC9C,CAAC,SAAS;IACR,IAAI,CACF,MAAM,EAAE,sCAAsC,GAC7C,gCAAgC,CAAC;CACrC,EACD,SAAS,EAAE,CAAC,GAAG,mCAAmC,CAUnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,wCAAwC,CACtD,YAAY,EAAE,mCAAmC,EACjD,OAAO,EAAE,GAAG,GAAG,WAAW,GACzB,8BAA8B,CAahC"}

package/dist/featureFlags/feature-flags.mjs

@@ -0,0 +1,112 @@
+import { isCaipChainId, KnownCaipNamespace, numberToHex, parseCaipChainId } from "@metamask/utils";
+import { DEFAULT_DISABLED_SMART_TRANSACTIONS_FEATURE_FLAGS } from "../constants.mjs";
+import { validateSmartTransactionsFeatureFlags } from "./validators.mjs";
+/**
+ * Normalizes a chain ID to hex format for EVM chains.
+ * - CAIP-2 EVM format (eip155:X) is converted to hex (0xY)
+ * - Hex format is returned as-is
+ * - Non-EVM CAIP-2 formats are returned as-is (exact match)
+ * - Invalid eip155 formats (non-numeric reference) are returned as-is
+ * - This is used because the current STX chains are EVM and declared as hex chain IDs in the existing flag.
+ *
+ * @param chainId - The chain ID in any supported format
+ * @returns Normalized chain ID (hex for EVM, original for non-EVM)
+ * @example
+ * ```ts
+ * normalizeChainId('0x1')           // → '0x1'
+ * normalizeChainId('eip155:1')      // → '0x1'
+ * normalizeChainId('eip155:137')    // → '0x89'
+ * normalizeChainId('solana:...')    // → 'solana:...' (unchanged)
+ * normalizeChainId('eip155:abc')    // → 'eip155:abc' (invalid, unchanged)
+ * ```
+ */
+export function normalizeChainId(chainId) {
+    // If it's already hex or not a valid CAIP chain ID, return as-is
+    if (!isCaipChainId(chainId)) {
+        return chainId;
+    }
+    const { namespace, reference } = parseCaipChainId(chainId);
+    // Only normalize EVM CAIP-2 chains with valid numeric references to hex
+    if (namespace === KnownCaipNamespace.Eip155) {
+        const decimal = parseInt(reference, 10);
+        // If reference is not a valid number, return as-is
+        if (Number.isNaN(decimal)) {
+            return chainId;
+        }
+        return numberToHex(decimal);
+    }
+    // Non-EVM CAIP chains remain unchanged
+    return chainId;
+}
+/**
+ * Processes raw feature flags data and returns a validated configuration.
+ * Invalid chain configs are silently removed. Error reporting is handled by
+ * the SmartTransactionsController via ErrorReportingService.
+ *
+ * @param rawFeatureFlags - The raw feature flags data from the remote feature flag controller
+ * @returns The validated feature flags configuration (partial if some chains were invalid)
+ */
+export function processSmartTransactionsFeatureFlags(rawFeatureFlags) {
+    const { config } = validateSmartTransactionsFeatureFlags(rawFeatureFlags);
+    // Return config if it has any valid data, otherwise return defaults
+    if (Object.keys(config).length > 0) {
+        return config;
+    }
+    return DEFAULT_DISABLED_SMART_TRANSACTIONS_FEATURE_FLAGS;
+}
+/**
+ * Gets the smart transactions feature flags from the remote feature flag controller.
+ *
+ * @param messenger - Any messenger with access to RemoteFeatureFlagController:getState
+ * @returns The smart transactions feature flags configuration
+ * @example
+ * ```ts
+ * const featureFlags = getSmartTransactionsFeatureFlags(messenger);
+ * const chainConfig = featureFlags['0x1'] ?? featureFlags.default;
+ * ```
+ */
+export function getSmartTransactionsFeatureFlags(messenger) {
+    var _a;
+    const remoteFeatureFlagControllerState = messenger.call('RemoteFeatureFlagController:getState');
+    const rawSmartTransactionsNetworks = (_a = remoteFeatureFlagControllerState === null || remoteFeatureFlagControllerState === void 0 ? void 0 : remoteFeatureFlagControllerState.remoteFeatureFlags) === null || _a === void 0 ? void 0 : _a.smartTransactionsNetworks;
+    return processSmartTransactionsFeatureFlags(rawSmartTransactionsNetworks);
+}
+/**
+ * Gets the merged feature flags configuration for a specific chain.
+ * Chain-specific configuration takes precedence over default configuration.
+ *
+ * For EVM chains, the chain ID is normalized to hex format before lookup.
+ * This means both '0x1' and 'eip155:1' will resolve to the same configuration.
+ * Non-EVM chains (e.g., Solana, Bitcoin) use exact match.
+ *
+ * @param featureFlags - The full feature flags configuration
+ * @param chainId - The chain ID to get configuration for.
+ * Supports both hex (e.g., "0x1") and CAIP-2 format (e.g., "eip155:1", "solana:...")
+ * @returns The merged configuration for the specified chain
+ * @example
+ * ```ts
+ * const featureFlags = getSmartTransactionsFeatureFlags(messenger);
+ *
+ * // Both resolve to the same config (normalized to 0x1)
+ * const chainConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, '0x1');
+ * const sameConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, 'eip155:1');
+ *
+ * // Non-EVM uses exact match
+ * const solanaConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp');
+ *
+ * if (chainConfig.extensionActive) {
+ *   // Smart transactions are enabled for this chain
+ * }
+ * ```
+ */
+export function getSmartTransactionsFeatureFlagsForChain(featureFlags, chainId) {
+    var _a;
+    const normalizedChainId = normalizeChainId(chainId);
+    const defaultRemoteConfig = (_a = featureFlags.default) !== null && _a !== void 0 ? _a : {};
+    const chainRemoteConfig = featureFlags[normalizedChainId];
+    if (chainRemoteConfig === undefined) {
+        return DEFAULT_DISABLED_SMART_TRANSACTIONS_FEATURE_FLAGS.default;
+    }
+    return Object.assign(Object.assign({}, defaultRemoteConfig), chainRemoteConfig);
+}
+//# sourceMappingURL=feature-flags.mjs.map

package/dist/featureFlags/feature-flags.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flags.mjs","sourceRoot":"","sources":["../../src/featureFlags/feature-flags.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,WAAW,EACX,gBAAgB,EACjB,wBAAwB;AAEzB,OAAO,EAAE,iDAAiD,EAAE,yBAAqB;AAKjF,OAAO,EAAE,qCAAqC,EAAE,yBAAqB;AAErE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,gBAAgB,CAC9B,OAA0B;IAE1B,iEAAiE;IACjE,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE;QAC3B,OAAO,OAAO,CAAC;KAChB;IAED,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAE3D,wEAAwE;IACxE,IAAI,SAAS,KAAK,kBAAkB,CAAC,MAAM,EAAE;QAC3C,MAAM,OAAO,GAAG,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;QACxC,mDAAmD;QACnD,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE;YACzB,OAAO,OAAO,CAAC;SAChB;QACD,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC;KAC7B;IAED,uCAAuC;IACvC,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,oCAAoC,CAClD,eAAwB;IAExB,MAAM,EAAE,MAAM,EAAE,GAAG,qCAAqC,CAAC,eAAe,CAAC,CAAC;IAE1E,oEAAoE;IACpE,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;QAClC,OAAO,MAAM,CAAC;KACf;IAED,OAAO,iDAAiD,CAAC;AAC3D,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gCAAgC,CAM9C,SAAY;;IACZ,MAAM,gCAAgC,GAAG,SAAS,CAAC,IAAI,CACrD,sCAAsC,CACvC,CAAC;IAEF,MAAM,4BAA4B,GAChC,MAAA,gCAAgC,aAAhC,gCAAgC,uBAAhC,gCAAgC,CAAE,kBAAkB,0CAChD,yBAAyB,CAAC;IAEhC,OAAO,oCAAoC,CAAC,4BAA4B,CAAC,CAAC;AAC5E,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,wCAAwC,CACtD,YAAiD,EACjD,OAA0B;;IAE1B,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACpD,MAAM,mBAAmB,GAAG,MAAA,YAAY,CAAC,OAAO,mCAAI,EAAE,CAAC;IACvD,MAAM,iBAAiB,GAAG,YAAY,CAAC,iBAAiB,CAAC,CAAC;IAE1D,IAAI,iBAAiB,KAAK,SAAS,EAAE;QACnC,OAAO,iDAAiD,CAAC,OAAO,CAAC;KAClE;IAED,uCACK,mBAAmB,GACnB,iBAAiB,EACpB;AACJ,CAAC","sourcesContent":["import type { RemoteFeatureFlagControllerState } from '@metamask/remote-feature-flag-controller';\nimport type { CaipChainId, Hex } from '@metamask/utils';\nimport {\n  isCaipChainId,\n  KnownCaipNamespace,\n  numberToHex,\n  parseCaipChainId,\n} from '@metamask/utils';\n\nimport { DEFAULT_DISABLED_SMART_TRANSACTIONS_FEATURE_FLAGS } from '../constants';\nimport type {\n  SmartTransactionsFeatureFlagsConfig,\n  SmartTransactionsNetworkConfig,\n} from '../types';\nimport { validateSmartTransactionsFeatureFlags } from './validators';\n\n/**\n * Normalizes a chain ID to hex format for EVM chains.\n * - CAIP-2 EVM format (eip155:X) is converted to hex (0xY)\n * - Hex format is returned as-is\n * - Non-EVM CAIP-2 formats are returned as-is (exact match)\n * - Invalid eip155 formats (non-numeric reference) are returned as-is\n * - This is used because the current STX chains are EVM and declared as hex chain IDs in the existing flag.\n *\n * @param chainId - The chain ID in any supported format\n * @returns Normalized chain ID (hex for EVM, original for non-EVM)\n * @example\n * ```ts\n * normalizeChainId('0x1')           // → '0x1'\n * normalizeChainId('eip155:1')      // → '0x1'\n * normalizeChainId('eip155:137')    // → '0x89'\n * normalizeChainId('solana:...')    // → 'solana:...' (unchanged)\n * normalizeChainId('eip155:abc')    // → 'eip155:abc' (invalid, unchanged)\n * ```\n */\nexport function normalizeChainId(\n  chainId: Hex | CaipChainId,\n): Hex | CaipChainId {\n  // If it's already hex or not a valid CAIP chain ID, return as-is\n  if (!isCaipChainId(chainId)) {\n    return chainId;\n  }\n\n  const { namespace, reference } = parseCaipChainId(chainId);\n\n  // Only normalize EVM CAIP-2 chains with valid numeric references to hex\n  if (namespace === KnownCaipNamespace.Eip155) {\n    const decimal = parseInt(reference, 10);\n    // If reference is not a valid number, return as-is\n    if (Number.isNaN(decimal)) {\n      return chainId;\n    }\n    return numberToHex(decimal);\n  }\n\n  // Non-EVM CAIP chains remain unchanged\n  return chainId;\n}\n\n/**\n * Processes raw feature flags data and returns a validated configuration.\n * Invalid chain configs are silently removed. Error reporting is handled by\n * the SmartTransactionsController via ErrorReportingService.\n *\n * @param rawFeatureFlags - The raw feature flags data from the remote feature flag controller\n * @returns The validated feature flags configuration (partial if some chains were invalid)\n */\nexport function processSmartTransactionsFeatureFlags(\n  rawFeatureFlags: unknown,\n): SmartTransactionsFeatureFlagsConfig {\n  const { config } = validateSmartTransactionsFeatureFlags(rawFeatureFlags);\n\n  // Return config if it has any valid data, otherwise return defaults\n  if (Object.keys(config).length > 0) {\n    return config;\n  }\n\n  return DEFAULT_DISABLED_SMART_TRANSACTIONS_FEATURE_FLAGS;\n}\n\n/**\n * Gets the smart transactions feature flags from the remote feature flag controller.\n *\n * @param messenger - Any messenger with access to RemoteFeatureFlagController:getState\n * @returns The smart transactions feature flags configuration\n * @example\n * ```ts\n * const featureFlags = getSmartTransactionsFeatureFlags(messenger);\n * const chainConfig = featureFlags['0x1'] ?? featureFlags.default;\n * ```\n */\nexport function getSmartTransactionsFeatureFlags<\n  T extends {\n    call(\n      action: 'RemoteFeatureFlagController:getState',\n    ): RemoteFeatureFlagControllerState;\n  },\n>(messenger: T): SmartTransactionsFeatureFlagsConfig {\n  const remoteFeatureFlagControllerState = messenger.call(\n    'RemoteFeatureFlagController:getState',\n  );\n\n  const rawSmartTransactionsNetworks =\n    remoteFeatureFlagControllerState?.remoteFeatureFlags\n      ?.smartTransactionsNetworks;\n\n  return processSmartTransactionsFeatureFlags(rawSmartTransactionsNetworks);\n}\n\n/**\n * Gets the merged feature flags configuration for a specific chain.\n * Chain-specific configuration takes precedence over default configuration.\n *\n * For EVM chains, the chain ID is normalized to hex format before lookup.\n * This means both '0x1' and 'eip155:1' will resolve to the same configuration.\n * Non-EVM chains (e.g., Solana, Bitcoin) use exact match.\n *\n * @param featureFlags - The full feature flags configuration\n * @param chainId - The chain ID to get configuration for.\n * Supports both hex (e.g., \"0x1\") and CAIP-2 format (e.g., \"eip155:1\", \"solana:...\")\n * @returns The merged configuration for the specified chain\n * @example\n * ```ts\n * const featureFlags = getSmartTransactionsFeatureFlags(messenger);\n *\n * // Both resolve to the same config (normalized to 0x1)\n * const chainConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, '0x1');\n * const sameConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, 'eip155:1');\n *\n * // Non-EVM uses exact match\n * const solanaConfig = getSmartTransactionsFeatureFlagsForChain(featureFlags, 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp');\n *\n * if (chainConfig.extensionActive) {\n *   // Smart transactions are enabled for this chain\n * }\n * ```\n */\nexport function getSmartTransactionsFeatureFlagsForChain(\n  featureFlags: SmartTransactionsFeatureFlagsConfig,\n  chainId: Hex | CaipChainId,\n): SmartTransactionsNetworkConfig {\n  const normalizedChainId = normalizeChainId(chainId);\n  const defaultRemoteConfig = featureFlags.default ?? {};\n  const chainRemoteConfig = featureFlags[normalizedChainId];\n\n  if (chainRemoteConfig === undefined) {\n    return DEFAULT_DISABLED_SMART_TRANSACTIONS_FEATURE_FLAGS.default;\n  }\n\n  return {\n    ...defaultRemoteConfig,\n    ...chainRemoteConfig,\n  };\n}\n"]}

package/dist/featureFlags/index.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeChainId = exports.getSmartTransactionsFeatureFlagsForChain = exports.processSmartTransactionsFeatureFlags = exports.getSmartTransactionsFeatureFlags = exports.SmartTransactionsFeatureFlagsConfigSchema = exports.SmartTransactionsNetworkConfigSchema = exports.validateSmartTransactionsNetworkConfig = exports.validateSmartTransactionsFeatureFlags = void 0;
+var validators_1 = require("./validators.cjs");
+Object.defineProperty(exports, "validateSmartTransactionsFeatureFlags", { enumerable: true, get: function () { return validators_1.validateSmartTransactionsFeatureFlags; } });
+Object.defineProperty(exports, "validateSmartTransactionsNetworkConfig", { enumerable: true, get: function () { return validators_1.validateSmartTransactionsNetworkConfig; } });
+Object.defineProperty(exports, "SmartTransactionsNetworkConfigSchema", { enumerable: true, get: function () { return validators_1.SmartTransactionsNetworkConfigSchema; } });
+Object.defineProperty(exports, "SmartTransactionsFeatureFlagsConfigSchema", { enumerable: true, get: function () { return validators_1.SmartTransactionsFeatureFlagsConfigSchema; } });
+var feature_flags_1 = require("./feature-flags.cjs");
+Object.defineProperty(exports, "getSmartTransactionsFeatureFlags", { enumerable: true, get: function () { return feature_flags_1.getSmartTransactionsFeatureFlags; } });
+Object.defineProperty(exports, "processSmartTransactionsFeatureFlags", { enumerable: true, get: function () { return feature_flags_1.processSmartTransactionsFeatureFlags; } });
+Object.defineProperty(exports, "getSmartTransactionsFeatureFlagsForChain", { enumerable: true, get: function () { return feature_flags_1.getSmartTransactionsFeatureFlagsForChain; } });
+Object.defineProperty(exports, "normalizeChainId", { enumerable: true, get: function () { return feature_flags_1.normalizeChainId; } });
+//# sourceMappingURL=index.cjs.map

package/dist/featureFlags/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../../src/featureFlags/index.ts"],"names":[],"mappings":";;;AAAA,+CASsB;AARpB,mIAAA,qCAAqC,OAAA;AACrC,oIAAA,sCAAsC,OAAA;AACtC,kIAAA,oCAAoC,OAAA;AACpC,uIAAA,yCAAyC,OAAA;AAO3C,qDAKyB;AAJvB,iIAAA,gCAAgC,OAAA;AAChC,qIAAA,oCAAoC,OAAA;AACpC,yIAAA,wCAAwC,OAAA;AACxC,iHAAA,gBAAgB,OAAA","sourcesContent":["export {\n  validateSmartTransactionsFeatureFlags,\n  validateSmartTransactionsNetworkConfig,\n  SmartTransactionsNetworkConfigSchema,\n  SmartTransactionsFeatureFlagsConfigSchema,\n  type SmartTransactionsNetworkConfigFromSchema,\n  type SmartTransactionsNetworkConfigFromSchema as SmartTransactionsNetworkConfig,\n  type SmartTransactionsFeatureFlagsConfigFromSchema,\n  type FeatureFlagsProcessResult,\n} from './validators';\n\nexport {\n  getSmartTransactionsFeatureFlags,\n  processSmartTransactionsFeatureFlags,\n  getSmartTransactionsFeatureFlagsForChain,\n  normalizeChainId,\n} from './feature-flags';\n"]}

package/dist/featureFlags/index.d.cts

@@ -0,0 +1,3 @@
+export { validateSmartTransactionsFeatureFlags, validateSmartTransactionsNetworkConfig, SmartTransactionsNetworkConfigSchema, SmartTransactionsFeatureFlagsConfigSchema, type SmartTransactionsNetworkConfigFromSchema, type SmartTransactionsNetworkConfigFromSchema as SmartTransactionsNetworkConfig, type SmartTransactionsFeatureFlagsConfigFromSchema, type FeatureFlagsProcessResult, } from "./validators.cjs";
+export { getSmartTransactionsFeatureFlags, processSmartTransactionsFeatureFlags, getSmartTransactionsFeatureFlagsForChain, normalizeChainId, } from "./feature-flags.cjs";
+//# sourceMappingURL=index.d.cts.map

package/dist/featureFlags/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../../src/featureFlags/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qCAAqC,EACrC,sCAAsC,EACtC,oCAAoC,EACpC,yCAAyC,EACzC,KAAK,wCAAwC,EAC7C,KAAK,wCAAwC,IAAI,8BAA8B,EAC/E,KAAK,6CAA6C,EAClD,KAAK,yBAAyB,GAC/B,yBAAqB;AAEtB,OAAO,EACL,gCAAgC,EAChC,oCAAoC,EACpC,wCAAwC,EACxC,gBAAgB,GACjB,4BAAwB"}

package/dist/featureFlags/index.d.mts

@@ -0,0 +1,3 @@
+export { validateSmartTransactionsFeatureFlags, validateSmartTransactionsNetworkConfig, SmartTransactionsNetworkConfigSchema, SmartTransactionsFeatureFlagsConfigSchema, type SmartTransactionsNetworkConfigFromSchema, type SmartTransactionsNetworkConfigFromSchema as SmartTransactionsNetworkConfig, type SmartTransactionsFeatureFlagsConfigFromSchema, type FeatureFlagsProcessResult, } from "./validators.mjs";
+export { getSmartTransactionsFeatureFlags, processSmartTransactionsFeatureFlags, getSmartTransactionsFeatureFlagsForChain, normalizeChainId, } from "./feature-flags.mjs";
+//# sourceMappingURL=index.d.mts.map

package/dist/featureFlags/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/featureFlags/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qCAAqC,EACrC,sCAAsC,EACtC,oCAAoC,EACpC,yCAAyC,EACzC,KAAK,wCAAwC,EAC7C,KAAK,wCAAwC,IAAI,8BAA8B,EAC/E,KAAK,6CAA6C,EAClD,KAAK,yBAAyB,GAC/B,yBAAqB;AAEtB,OAAO,EACL,gCAAgC,EAChC,oCAAoC,EACpC,wCAAwC,EACxC,gBAAgB,GACjB,4BAAwB"}

package/dist/featureFlags/index.mjs

@@ -0,0 +1,3 @@
+export { validateSmartTransactionsFeatureFlags, validateSmartTransactionsNetworkConfig, SmartTransactionsNetworkConfigSchema, SmartTransactionsFeatureFlagsConfigSchema } from "./validators.mjs";
+export { getSmartTransactionsFeatureFlags, processSmartTransactionsFeatureFlags, getSmartTransactionsFeatureFlagsForChain, normalizeChainId } from "./feature-flags.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/featureFlags/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/featureFlags/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qCAAqC,EACrC,sCAAsC,EACtC,oCAAoC,EACpC,yCAAyC,EAK1C,yBAAqB;AAEtB,OAAO,EACL,gCAAgC,EAChC,oCAAoC,EACpC,wCAAwC,EACxC,gBAAgB,EACjB,4BAAwB","sourcesContent":["export {\n  validateSmartTransactionsFeatureFlags,\n  validateSmartTransactionsNetworkConfig,\n  SmartTransactionsNetworkConfigSchema,\n  SmartTransactionsFeatureFlagsConfigSchema,\n  type SmartTransactionsNetworkConfigFromSchema,\n  type SmartTransactionsNetworkConfigFromSchema as SmartTransactionsNetworkConfig,\n  type SmartTransactionsFeatureFlagsConfigFromSchema,\n  type FeatureFlagsProcessResult,\n} from './validators';\n\nexport {\n  getSmartTransactionsFeatureFlags,\n  processSmartTransactionsFeatureFlags,\n  getSmartTransactionsFeatureFlagsForChain,\n  normalizeChainId,\n} from './feature-flags';\n"]}

package/dist/featureFlags/validators.cjs

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSmartTransactionsNetworkConfig = exports.validateSmartTransactionsFeatureFlags = exports.SmartTransactionsFeatureFlagsConfigSchema = exports.SmartTransactionsNetworkConfigSchema = void 0;
+const superstruct_1 = require("@metamask/superstruct");
+const utils_1 = require("@metamask/utils");
+/**
+ * Validates that a key is a valid chain ID (hex or CAIP-2 format).
+ * Supports both EVM hex chain IDs and chain-agnostic CAIP-2 identifiers.
+ *
+ * @param key - The key to validate
+ * @returns True if the key is a valid chain ID format
+ */
+function isValidChainIdKey(key) {
+    return (0, utils_1.isStrictHexString)(key) || (0, utils_1.isCaipChainId)(key);
+}
+/**
+ * Schema for validating per-network smart transactions configuration.
+ * All fields are optional to allow partial configuration and merging with defaults.
+ */
+exports.SmartTransactionsNetworkConfigSchema = (0, superstruct_1.type)({
+    /** Whether smart transactions are active for the extension client */
+    extensionActive: (0, superstruct_1.optional)((0, superstruct_1.boolean)()),
+    /** Whether smart transactions are active for mobile clients (generic) */
+    mobileActive: (0, superstruct_1.optional)((0, superstruct_1.boolean)()),
+    /** Whether smart transactions are active for iOS specifically */
+    mobileActiveIOS: (0, superstruct_1.optional)((0, superstruct_1.boolean)()),
+    /** Whether smart transactions are active for Android specifically */
+    mobileActiveAndroid: (0, superstruct_1.optional)((0, superstruct_1.boolean)()),
+    /** Expected time in seconds for a smart transaction to be mined */
+    expectedDeadline: (0, superstruct_1.optional)((0, superstruct_1.number)()),
+    /** Maximum time in seconds before a smart transaction is considered failed */
+    maxDeadline: (0, superstruct_1.optional)((0, superstruct_1.number)()),
+    /** Whether extension should return tx hash immediately without waiting for confirmation */
+    extensionReturnTxHashAsap: (0, superstruct_1.optional)((0, superstruct_1.boolean)()),
+    /** Whether extension should return tx hash immediately for batch transactions */
+    extensionReturnTxHashAsapBatch: (0, superstruct_1.optional)((0, superstruct_1.boolean)()),
+    /** Whether mobile should return tx hash immediately without waiting for confirmation */
+    mobileReturnTxHashAsap: (0, superstruct_1.optional)((0, superstruct_1.boolean)()),
+    /** Whether extension should skip the smart transaction status page */
+    extensionSkipSmartTransactionStatusPage: (0, superstruct_1.optional)((0, superstruct_1.boolean)()),
+    /** Polling interval in milliseconds for batch status updates */
+    batchStatusPollingInterval: (0, superstruct_1.optional)((0, superstruct_1.number)()),
+    /** Custom sentinel URL for the network */
+    sentinelUrl: (0, superstruct_1.optional)((0, superstruct_1.string)()),
+});
+/**
+ * Schema for validating the complete smart transactions feature flags configuration.
+ * This includes a default configuration and optional chain-specific overrides.
+ */
+exports.SmartTransactionsFeatureFlagsConfigSchema = (0, superstruct_1.type)({
+    /** Default configuration applied to all chains unless overridden */
+    default: (0, superstruct_1.optional)(exports.SmartTransactionsNetworkConfigSchema),
+});
+/**
+ * Validates smart transactions feature flags with per-chain validation.
+ * - If the input is not an object, returns empty config with error
+ * - If `default` is present and invalid, returns empty config with error
+ * - For each chain: if invalid, removes it and collects error; if valid, includes it
+ *
+ * @param data - The data to validate
+ * @returns The validated config and any validation errors
+ */
+function validateSmartTransactionsFeatureFlags(data) {
+    const errors = [];
+    // Step 1: Check if it's a valid object
+    if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+        const typeDescription = data === null ? 'null' : typeof data;
+        const arraySuffix = Array.isArray(data) ? ' (array)' : '';
+        return {
+            config: {},
+            errors: [
+                new Error(`Expected an object, received ${typeDescription}${arraySuffix}`),
+            ],
+        };
+    }
+    const dataRecord = data;
+    const validConfig = {};
+    // Step 2: Validate 'default' - if present and invalid, reject everything
+    if (dataRecord.default !== undefined) {
+        const [defaultError, validatedDefault] = (0, superstruct_1.validate)(dataRecord.default, exports.SmartTransactionsNetworkConfigSchema);
+        if (defaultError) {
+            return {
+                config: {},
+                errors: [
+                    new Error(`Invalid 'default' config: ${defaultError.message}`),
+                ],
+            };
+        }
+        // validatedDefault is properly typed from superstruct
+        validConfig.default = validatedDefault;
+    }
+    // Step 3: Validate chain-specific configs, keeping valid ones
+    for (const [key, value] of Object.entries(dataRecord)) {
+        if (key === 'default') {
+            continue;
+        }
+        // Check chain ID format
+        if (!isValidChainIdKey(key)) {
+            errors.push(new Error(`Invalid chain ID key "${key}". Expected hex string (e.g., "0x1") or CAIP-2 format (e.g., "eip155:1", "solana:...")`));
+            continue; // Skip this chain, don't add to result
+        }
+        // Validate chain config
+        if (value !== undefined) {
+            const [chainError, validatedChain] = (0, superstruct_1.validate)(value, exports.SmartTransactionsNetworkConfigSchema);
+            if (chainError) {
+                errors.push(new Error(`Chain "${key}": ${chainError.message}`));
+                continue; // Skip this chain, don't add to result
+            }
+            // validatedChain is properly typed from superstruct
+            validConfig[key] = validatedChain;
+        }
+    }
+    return { config: validConfig, errors };
+}
+exports.validateSmartTransactionsFeatureFlags = validateSmartTransactionsFeatureFlags;
+/**
+ * Validates that the given data conforms to the SmartTransactionsNetworkConfig schema.
+ *
+ * @param data - The data to validate
+ * @returns True if the data is valid, false otherwise
+ */
+function validateSmartTransactionsNetworkConfig(data) {
+    return (0, superstruct_1.is)(data, exports.SmartTransactionsNetworkConfigSchema);
+}
+exports.validateSmartTransactionsNetworkConfig = validateSmartTransactionsNetworkConfig;
+//# sourceMappingURL=validators.cjs.map

package/dist/featureFlags/validators.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.cjs","sourceRoot":"","sources":["../../src/featureFlags/validators.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  boolean,\n  number,\n  optional,\n  string,\n  type,\n  is,\n  validate,\n} from '@metamask/superstruct';\nimport type { Infer } from '@metamask/superstruct';\nimport { isCaipChainId, isStrictHexString } from '@metamask/utils';\n\n/**\n * Validates that a key is a valid chain ID (hex or CAIP-2 format).\n * Supports both EVM hex chain IDs and chain-agnostic CAIP-2 identifiers.\n *\n * @param key - The key to validate\n * @returns True if the key is a valid chain ID format\n */\nfunction isValidChainIdKey(key: string): boolean {\n  return isStrictHexString(key) || isCaipChainId(key);\n}\n\n/**\n * Schema for validating per-network smart transactions configuration.\n * All fields are optional to allow partial configuration and merging with defaults.\n */\nexport const SmartTransactionsNetworkConfigSchema = type({\n  /** Whether smart transactions are active for the extension client */\n  extensionActive: optional(boolean()),\n  /** Whether smart transactions are active for mobile clients (generic) */\n  mobileActive: optional(boolean()),\n  /** Whether smart transactions are active for iOS specifically */\n  mobileActiveIOS: optional(boolean()),\n  /** Whether smart transactions are active for Android specifically */\n  mobileActiveAndroid: optional(boolean()),\n  /** Expected time in seconds for a smart transaction to be mined */\n  expectedDeadline: optional(number()),\n  /** Maximum time in seconds before a smart transaction is considered failed */\n  maxDeadline: optional(number()),\n  /** Whether extension should return tx hash immediately without waiting for confirmation */\n  extensionReturnTxHashAsap: optional(boolean()),\n  /** Whether extension should return tx hash immediately for batch transactions */\n  extensionReturnTxHashAsapBatch: optional(boolean()),\n  /** Whether mobile should return tx hash immediately without waiting for confirmation */\n  mobileReturnTxHashAsap: optional(boolean()),\n  /** Whether extension should skip the smart transaction status page */\n  extensionSkipSmartTransactionStatusPage: optional(boolean()),\n  /** Polling interval in milliseconds for batch status updates */\n  batchStatusPollingInterval: optional(number()),\n  /** Custom sentinel URL for the network */\n  sentinelUrl: optional(string()),\n});\n\n/**\n * Schema for validating the complete smart transactions feature flags configuration.\n * This includes a default configuration and optional chain-specific overrides.\n */\nexport const SmartTransactionsFeatureFlagsConfigSchema = type({\n  /** Default configuration applied to all chains unless overridden */\n  default: optional(SmartTransactionsNetworkConfigSchema),\n});\n\n/**\n * Type inferred from the SmartTransactionsNetworkConfigSchema\n */\nexport type SmartTransactionsNetworkConfigFromSchema = Infer<\n  typeof SmartTransactionsNetworkConfigSchema\n>;\n\n/**\n * Type inferred from the SmartTransactionsFeatureFlagsConfigSchema\n */\nexport type SmartTransactionsFeatureFlagsConfigFromSchema = Infer<\n  typeof SmartTransactionsFeatureFlagsConfigSchema\n>;\n\n/**\n * Result of processing feature flags with collected validation errors.\n * Uses per-chain validation: invalid chains are removed, valid ones are kept.\n */\nexport type FeatureFlagsProcessResult = {\n  /** The validated configuration (may be partial if some chains were invalid) */\n  config: SmartTransactionsFeatureFlagsConfigFromSchema &\n    Record<string, SmartTransactionsNetworkConfigFromSchema | undefined>;\n  /** Validation errors for invalid parts of the configuration */\n  errors: Error[];\n};\n\n/**\n * Validates smart transactions feature flags with per-chain validation.\n * - If the input is not an object, returns empty config with error\n * - If `default` is present and invalid, returns empty config with error\n * - For each chain: if invalid, removes it and collects error; if valid, includes it\n *\n * @param data - The data to validate\n * @returns The validated config and any validation errors\n */\nexport function validateSmartTransactionsFeatureFlags(\n  data: unknown,\n): FeatureFlagsProcessResult {\n  const errors: Error[] = [];\n\n  // Step 1: Check if it's a valid object\n  if (typeof data !== 'object' || data === null || Array.isArray(data)) {\n    const typeDescription = data === null ? 'null' : typeof data;\n    const arraySuffix = Array.isArray(data) ? ' (array)' : '';\n    return {\n      config: {},\n      errors: [\n        new Error(\n          `Expected an object, received ${typeDescription}${arraySuffix}`,\n        ),\n      ],\n    };\n  }\n\n  const dataRecord = data as Record<string, unknown>;\n  const validConfig: FeatureFlagsProcessResult['config'] = {};\n\n  // Step 2: Validate 'default' - if present and invalid, reject everything\n  if (dataRecord.default !== undefined) {\n    const [defaultError, validatedDefault] = validate(\n      dataRecord.default,\n      SmartTransactionsNetworkConfigSchema,\n    );\n    if (defaultError) {\n      return {\n        config: {},\n        errors: [\n          new Error(`Invalid 'default' config: ${defaultError.message}`),\n        ],\n      };\n    }\n    // validatedDefault is properly typed from superstruct\n    validConfig.default = validatedDefault;\n  }\n\n  // Step 3: Validate chain-specific configs, keeping valid ones\n  for (const [key, value] of Object.entries(dataRecord)) {\n    if (key === 'default') {\n      continue;\n    }\n\n    // Check chain ID format\n    if (!isValidChainIdKey(key)) {\n      errors.push(\n        new Error(\n          `Invalid chain ID key \"${key}\". Expected hex string (e.g., \"0x1\") or CAIP-2 format (e.g., \"eip155:1\", \"solana:...\")`,\n        ),\n      );\n      continue; // Skip this chain, don't add to result\n    }\n\n    // Validate chain config\n    if (value !== undefined) {\n      const [chainError, validatedChain] = validate(\n        value,\n        SmartTransactionsNetworkConfigSchema,\n      );\n      if (chainError) {\n        errors.push(new Error(`Chain \"${key}\": ${chainError.message}`));\n        continue; // Skip this chain, don't add to result\n      }\n      // validatedChain is properly typed from superstruct\n      validConfig[key] = validatedChain;\n    }\n  }\n\n  return { config: validConfig, errors };\n}\n\n/**\n * Validates that the given data conforms to the SmartTransactionsNetworkConfig schema.\n *\n * @param data - The data to validate\n * @returns True if the data is valid, false otherwise\n */\nexport function validateSmartTransactionsNetworkConfig(\n  data: unknown,\n): data is SmartTransactionsNetworkConfigFromSchema {\n  return is(data, SmartTransactionsNetworkConfigSchema);\n}\n"]}