@metamask/ramps-controller 20.2.0 → 21.0.0

package/dist/providerAvailability.cjs

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFiatDepositAvailable = exports.regionHasProviderForAsset = exports.getProvidersServingAsset = exports.providerServesAsset = exports.normalizeRampsAssetId = void 0;
-/**
- * Canonicalizes a CAIP-19 asset id for comparison against Ramps API values.
- *
- * CAIP-19 does not constrain the case of the asset reference, and the Ramps API
- * is not consistent about it. Every `eip155` key in `regions/{region}/providers`
- * `supportedCryptoCurrencies` is lowercase, while `regions/{region}/topTokens`
- * returns four mainnet `assetId` values EIP-55 checksummed (USDT, USDC, WBTC,
- * LINK) in both its `topTokens` and `allTokens` lists, with no lowercase
- * duplicate. Callers also supply checksummed ids of their own from other
- * controllers, so the two sides of a comparison can disagree on case for the
- * same asset.
- *
- * Non-EVM references are case-sensitive (Solana base58, Tron base58, bitcoin
- * bech32), so lowercasing is restricted to `eip155` rather than applied to the
- * whole string. This is a tightening: for EVM ids a plain `toLowerCase()` on
- * both sides already matched. Current API data carries non-EVM ids in identical
- * case on both endpoints, so the passthrough guards against future drift rather
- * than fixing an observed mismatch.
- *
- * The namespace itself is matched case-insensitively, so an `EIP155:` prefix
- * is treated as EVM even though CAIP-19 defines namespaces as lowercase.
- *
- * @param assetId - CAIP-19 asset id, in either case form.
- * @returns The asset id in the form the Ramps API uses.
- */
-function normalizeRampsAssetId(assetId) {
-    const trimmedAssetId = assetId.trim();
-    return /^eip155:/iu.test(trimmedAssetId)
-        ? trimmedAssetId.toLowerCase()
-        : trimmedAssetId;
-}
-exports.normalizeRampsAssetId = normalizeRampsAssetId;
-/**
- * Whether a provider serves the given deposit asset.
- *
- * Mirrors the region-provider matching the controller performs internally: a
- * provider serves the asset when its `supportedCryptoCurrencies` map (keyed by
- * CAIP-19 asset id) contains the asset id. Both sides are canonicalized with
- * {@link normalizeRampsAssetId}, so EVM ids match regardless of checksum
- * casing while non-EVM references stay case-sensitive. A provider without a
- * `supportedCryptoCurrencies` map is treated as not serving the asset.
- *
- * @param provider - The provider to test.
- * @param assetId - CAIP-19 asset id of the deposit asset.
- * @returns Whether the provider serves the asset.
- */
-function providerServesAsset(provider, assetId) {
-    const map = provider?.supportedCryptoCurrencies;
-    if (!map) {
-        return false;
-    }
-    const target = normalizeRampsAssetId(assetId);
-    return Object.keys(map).some((key) => normalizeRampsAssetId(key) === target && map[key]);
-}
-exports.providerServesAsset = providerServesAsset;
-/**
- * Filters a provider list down to those serving the given deposit asset.
- *
- * @param providers - The providers to filter.
- * @param assetId - CAIP-19 asset id of the deposit asset.
- * @returns The subset of providers serving the asset.
- */
-function getProvidersServingAsset(providers, assetId) {
-    return providers.filter((provider) => providerServesAsset(provider, assetId));
-}
-exports.getProvidersServingAsset = getProvidersServingAsset;
-/**
- * Whether a region offers a usable on-ramp provider that serves the given
- * deposit asset, under the all-providers feature flag. This is the pure,
- * asset-aware region gate shared between the controller and headless-buy
- * consumers so the two never disagree about eligibility.
- *
- * With `allProvidersEnabled` false the gate is native-only: the region must
- * offer a native provider (e.g. Transak Native) that serves the asset. With
- * `allProvidersEnabled` true the region is supported when any provider
- * (native or aggregator) serves the asset; the controller's flag-aware
- * `getQuotes` performs the precise provider selection at quote time. Fails
- * closed: an empty or missing `assetId` returns `false`.
- *
- * @param options - The options.
- * @param options.providers - The region's providers (native and aggregator).
- * @param options.assetId - CAIP-19 asset id of the deposit asset.
- * @param options.allProvidersEnabled - Whether the all-providers feature flag
- * is enabled (see `isHeadlessAllProvidersEnabled`).
- * @returns Whether the region has a provider serving the asset.
- */
-function regionHasProviderForAsset({ providers, assetId, allProvidersEnabled, }) {
-    if (!assetId) {
-        return false;
-    }
-    const serving = getProvidersServingAsset(providers, assetId);
-    if (serving.some((provider) => provider.type === 'native')) {
-        return true;
-    }
-    if (!allProvidersEnabled) {
-        return false;
-    }
-    return serving.length > 0;
-}
-exports.regionHasProviderForAsset = regionHasProviderForAsset;
-/**
- * Whether headless fiat deposit is available for the current region, under
- * the all-providers feature flag. Flag-aware and independent of which single
- * provider is currently selected once widened, so the availability gate
- * cannot disagree with the controller's own flag-aware provider pick.
- *
- * With `allProvidersEnabled` false the check keeps the native-only behaviour:
- * a native provider must be the currently selected (preferred) one, since the
- * controller resolves the selected provider first and an aggregator preferred
- * provider would otherwise run a non-native deposit. With
- * `allProvidersEnabled` true the flow is available whenever the region has
- * any provider.
- *
- * @param options - The options.
- * @param options.providers - The region's providers.
- * @param options.selectedProvider - The currently selected provider, if any.
- * @param options.allProvidersEnabled - Whether the all-providers feature flag
- * is enabled (see `isHeadlessAllProvidersEnabled`).
- * @returns Whether headless fiat deposit is available.
- */
-function isFiatDepositAvailable({ providers, selectedProvider, allProvidersEnabled, }) {
-    if (selectedProvider?.type === 'native') {
-        return true;
-    }
-    if (!allProvidersEnabled) {
-        return false;
-    }
-    return providers.length > 0;
-}
-exports.isFiatDepositAvailable = isFiatDepositAvailable;
-//# sourceMappingURL=providerAvailability.cjs.map

package/dist/providerAvailability.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"providerAvailability.cjs","sourceRoot":"","sources":["../src/providerAvailability.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,SAAgB,qBAAqB,CAAC,OAAe;IACnD,MAAM,cAAc,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IACtC,OAAO,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC;QACtC,CAAC,CAAC,cAAc,CAAC,WAAW,EAAE;QAC9B,CAAC,CAAC,cAAc,CAAC;AACrB,CAAC;AALD,sDAKC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,mBAAmB,CACjC,QAAkB,EAClB,OAAe;IAEf,MAAM,GAAG,GAAG,QAAQ,EAAE,yBAAyB,CAAC;IAChD,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,MAAM,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC;IAC9C,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAC1B,CAAC,GAAG,EAAE,EAAE,CAAC,qBAAqB,CAAC,GAAG,CAAC,KAAK,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,CAC3D,CAAC;AACJ,CAAC;AAZD,kDAYC;AAED;;;;;;GAMG;AACH,SAAgB,wBAAwB,CACtC,SAAqB,EACrB,OAAe;IAEf,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,mBAAmB,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;AAChF,CAAC;AALD,4DAKC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,yBAAyB,CAAC,EACxC,SAAS,EACT,OAAO,EACP,mBAAmB,GAKpB;IACC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,OAAO,GAAG,wBAAwB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IAC7D,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,EAAE,CAAC;QAC3D,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,CAAC,mBAAmB,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;AAC5B,CAAC;AApBD,8DAoBC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,sBAAsB,CAAC,EACrC,SAAS,EACT,gBAAgB,EAChB,mBAAmB,GAKpB;IACC,IAAI,gBAAgB,EAAE,IAAI,KAAK,QAAQ,EAAE,CAAC;QACxC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,CAAC,mBAAmB,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;AAC9B,CAAC;AAhBD,wDAgBC","sourcesContent":["import type { Provider } from './RampsService.js';\n\n/**\n * Canonicalizes a CAIP-19 asset id for comparison against Ramps API values.\n *\n * CAIP-19 does not constrain the case of the asset reference, and the Ramps API\n * is not consistent about it. Every `eip155` key in `regions/{region}/providers`\n * `supportedCryptoCurrencies` is lowercase, while `regions/{region}/topTokens`\n * returns four mainnet `assetId` values EIP-55 checksummed (USDT, USDC, WBTC,\n * LINK) in both its `topTokens` and `allTokens` lists, with no lowercase\n * duplicate. Callers also supply checksummed ids of their own from other\n * controllers, so the two sides of a comparison can disagree on case for the\n * same asset.\n *\n * Non-EVM references are case-sensitive (Solana base58, Tron base58, bitcoin\n * bech32), so lowercasing is restricted to `eip155` rather than applied to the\n * whole string. This is a tightening: for EVM ids a plain `toLowerCase()` on\n * both sides already matched. Current API data carries non-EVM ids in identical\n * case on both endpoints, so the passthrough guards against future drift rather\n * than fixing an observed mismatch.\n *\n * The namespace itself is matched case-insensitively, so an `EIP155:` prefix\n * is treated as EVM even though CAIP-19 defines namespaces as lowercase.\n *\n * @param assetId - CAIP-19 asset id, in either case form.\n * @returns The asset id in the form the Ramps API uses.\n */\nexport function normalizeRampsAssetId(assetId: string): string {\n  const trimmedAssetId = assetId.trim();\n  return /^eip155:/iu.test(trimmedAssetId)\n    ? trimmedAssetId.toLowerCase()\n    : trimmedAssetId;\n}\n\n/**\n * Whether a provider serves the given deposit asset.\n *\n * Mirrors the region-provider matching the controller performs internally: a\n * provider serves the asset when its `supportedCryptoCurrencies` map (keyed by\n * CAIP-19 asset id) contains the asset id. Both sides are canonicalized with\n * {@link normalizeRampsAssetId}, so EVM ids match regardless of checksum\n * casing while non-EVM references stay case-sensitive. A provider without a\n * `supportedCryptoCurrencies` map is treated as not serving the asset.\n *\n * @param provider - The provider to test.\n * @param assetId - CAIP-19 asset id of the deposit asset.\n * @returns Whether the provider serves the asset.\n */\nexport function providerServesAsset(\n  provider: Provider,\n  assetId: string,\n): boolean {\n  const map = provider?.supportedCryptoCurrencies;\n  if (!map) {\n    return false;\n  }\n  const target = normalizeRampsAssetId(assetId);\n  return Object.keys(map).some(\n    (key) => normalizeRampsAssetId(key) === target && map[key],\n  );\n}\n\n/**\n * Filters a provider list down to those serving the given deposit asset.\n *\n * @param providers - The providers to filter.\n * @param assetId - CAIP-19 asset id of the deposit asset.\n * @returns The subset of providers serving the asset.\n */\nexport function getProvidersServingAsset(\n  providers: Provider[],\n  assetId: string,\n): Provider[] {\n  return providers.filter((provider) => providerServesAsset(provider, assetId));\n}\n\n/**\n * Whether a region offers a usable on-ramp provider that serves the given\n * deposit asset, under the all-providers feature flag. This is the pure,\n * asset-aware region gate shared between the controller and headless-buy\n * consumers so the two never disagree about eligibility.\n *\n * With `allProvidersEnabled` false the gate is native-only: the region must\n * offer a native provider (e.g. Transak Native) that serves the asset. With\n * `allProvidersEnabled` true the region is supported when any provider\n * (native or aggregator) serves the asset; the controller's flag-aware\n * `getQuotes` performs the precise provider selection at quote time. Fails\n * closed: an empty or missing `assetId` returns `false`.\n *\n * @param options - The options.\n * @param options.providers - The region's providers (native and aggregator).\n * @param options.assetId - CAIP-19 asset id of the deposit asset.\n * @param options.allProvidersEnabled - Whether the all-providers feature flag\n * is enabled (see `isHeadlessAllProvidersEnabled`).\n * @returns Whether the region has a provider serving the asset.\n */\nexport function regionHasProviderForAsset({\n  providers,\n  assetId,\n  allProvidersEnabled,\n}: {\n  providers: Provider[];\n  assetId: string;\n  allProvidersEnabled: boolean;\n}): boolean {\n  if (!assetId) {\n    return false;\n  }\n  const serving = getProvidersServingAsset(providers, assetId);\n  if (serving.some((provider) => provider.type === 'native')) {\n    return true;\n  }\n  if (!allProvidersEnabled) {\n    return false;\n  }\n  return serving.length > 0;\n}\n\n/**\n * Whether headless fiat deposit is available for the current region, under\n * the all-providers feature flag. Flag-aware and independent of which single\n * provider is currently selected once widened, so the availability gate\n * cannot disagree with the controller's own flag-aware provider pick.\n *\n * With `allProvidersEnabled` false the check keeps the native-only behaviour:\n * a native provider must be the currently selected (preferred) one, since the\n * controller resolves the selected provider first and an aggregator preferred\n * provider would otherwise run a non-native deposit. With\n * `allProvidersEnabled` true the flow is available whenever the region has\n * any provider.\n *\n * @param options - The options.\n * @param options.providers - The region's providers.\n * @param options.selectedProvider - The currently selected provider, if any.\n * @param options.allProvidersEnabled - Whether the all-providers feature flag\n * is enabled (see `isHeadlessAllProvidersEnabled`).\n * @returns Whether headless fiat deposit is available.\n */\nexport function isFiatDepositAvailable({\n  providers,\n  selectedProvider,\n  allProvidersEnabled,\n}: {\n  providers: Provider[];\n  selectedProvider?: Provider | null;\n  allProvidersEnabled: boolean;\n}): boolean {\n  if (selectedProvider?.type === 'native') {\n    return true;\n  }\n  if (!allProvidersEnabled) {\n    return false;\n  }\n  return providers.length > 0;\n}\n"]}

package/dist/providerAvailability.d.cts

@@ -1,101 +0,0 @@
-import type { Provider } from "./RampsService.cjs";
-/**
- * Canonicalizes a CAIP-19 asset id for comparison against Ramps API values.
- *
- * CAIP-19 does not constrain the case of the asset reference, and the Ramps API
- * is not consistent about it. Every `eip155` key in `regions/{region}/providers`
- * `supportedCryptoCurrencies` is lowercase, while `regions/{region}/topTokens`
- * returns four mainnet `assetId` values EIP-55 checksummed (USDT, USDC, WBTC,
- * LINK) in both its `topTokens` and `allTokens` lists, with no lowercase
- * duplicate. Callers also supply checksummed ids of their own from other
- * controllers, so the two sides of a comparison can disagree on case for the
- * same asset.
- *
- * Non-EVM references are case-sensitive (Solana base58, Tron base58, bitcoin
- * bech32), so lowercasing is restricted to `eip155` rather than applied to the
- * whole string. This is a tightening: for EVM ids a plain `toLowerCase()` on
- * both sides already matched. Current API data carries non-EVM ids in identical
- * case on both endpoints, so the passthrough guards against future drift rather
- * than fixing an observed mismatch.
- *
- * The namespace itself is matched case-insensitively, so an `EIP155:` prefix
- * is treated as EVM even though CAIP-19 defines namespaces as lowercase.
- *
- * @param assetId - CAIP-19 asset id, in either case form.
- * @returns The asset id in the form the Ramps API uses.
- */
-export declare function normalizeRampsAssetId(assetId: string): string;
-/**
- * Whether a provider serves the given deposit asset.
- *
- * Mirrors the region-provider matching the controller performs internally: a
- * provider serves the asset when its `supportedCryptoCurrencies` map (keyed by
- * CAIP-19 asset id) contains the asset id. Both sides are canonicalized with
- * {@link normalizeRampsAssetId}, so EVM ids match regardless of checksum
- * casing while non-EVM references stay case-sensitive. A provider without a
- * `supportedCryptoCurrencies` map is treated as not serving the asset.
- *
- * @param provider - The provider to test.
- * @param assetId - CAIP-19 asset id of the deposit asset.
- * @returns Whether the provider serves the asset.
- */
-export declare function providerServesAsset(provider: Provider, assetId: string): boolean;
-/**
- * Filters a provider list down to those serving the given deposit asset.
- *
- * @param providers - The providers to filter.
- * @param assetId - CAIP-19 asset id of the deposit asset.
- * @returns The subset of providers serving the asset.
- */
-export declare function getProvidersServingAsset(providers: Provider[], assetId: string): Provider[];
-/**
- * Whether a region offers a usable on-ramp provider that serves the given
- * deposit asset, under the all-providers feature flag. This is the pure,
- * asset-aware region gate shared between the controller and headless-buy
- * consumers so the two never disagree about eligibility.
- *
- * With `allProvidersEnabled` false the gate is native-only: the region must
- * offer a native provider (e.g. Transak Native) that serves the asset. With
- * `allProvidersEnabled` true the region is supported when any provider
- * (native or aggregator) serves the asset; the controller's flag-aware
- * `getQuotes` performs the precise provider selection at quote time. Fails
- * closed: an empty or missing `assetId` returns `false`.
- *
- * @param options - The options.
- * @param options.providers - The region's providers (native and aggregator).
- * @param options.assetId - CAIP-19 asset id of the deposit asset.
- * @param options.allProvidersEnabled - Whether the all-providers feature flag
- * is enabled (see `isHeadlessAllProvidersEnabled`).
- * @returns Whether the region has a provider serving the asset.
- */
-export declare function regionHasProviderForAsset({ providers, assetId, allProvidersEnabled, }: {
-    providers: Provider[];
-    assetId: string;
-    allProvidersEnabled: boolean;
-}): boolean;
-/**
- * Whether headless fiat deposit is available for the current region, under
- * the all-providers feature flag. Flag-aware and independent of which single
- * provider is currently selected once widened, so the availability gate
- * cannot disagree with the controller's own flag-aware provider pick.
- *
- * With `allProvidersEnabled` false the check keeps the native-only behaviour:
- * a native provider must be the currently selected (preferred) one, since the
- * controller resolves the selected provider first and an aggregator preferred
- * provider would otherwise run a non-native deposit. With
- * `allProvidersEnabled` true the flow is available whenever the region has
- * any provider.
- *
- * @param options - The options.
- * @param options.providers - The region's providers.
- * @param options.selectedProvider - The currently selected provider, if any.
- * @param options.allProvidersEnabled - Whether the all-providers feature flag
- * is enabled (see `isHeadlessAllProvidersEnabled`).
- * @returns Whether headless fiat deposit is available.
- */
-export declare function isFiatDepositAvailable({ providers, selectedProvider, allProvidersEnabled, }: {
-    providers: Provider[];
-    selectedProvider?: Provider | null;
-    allProvidersEnabled: boolean;
-}): boolean;
-//# sourceMappingURL=providerAvailability.d.cts.map

package/dist/providerAvailability.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"providerAvailability.d.cts","sourceRoot":"","sources":["../src/providerAvailability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,2BAA0B;AAElD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAK7D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,MAAM,GACd,OAAO,CAST;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,QAAQ,EAAE,EACrB,OAAO,EAAE,MAAM,GACd,QAAQ,EAAE,CAEZ;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,SAAS,EACT,OAAO,EACP,mBAAmB,GACpB,EAAE;IACD,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB,EAAE,OAAO,CAAC;CAC9B,GAAG,OAAO,CAYV;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,SAAS,EACT,gBAAgB,EAChB,mBAAmB,GACpB,EAAE;IACD,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,gBAAgB,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IACnC,mBAAmB,EAAE,OAAO,CAAC;CAC9B,GAAG,OAAO,CAQV"}

package/dist/providerAvailability.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"providerAvailability.d.mts","sourceRoot":"","sources":["../src/providerAvailability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,2BAA0B;AAElD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAK7D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,MAAM,GACd,OAAO,CAST;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,QAAQ,EAAE,EACrB,OAAO,EAAE,MAAM,GACd,QAAQ,EAAE,CAEZ;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,SAAS,EACT,OAAO,EACP,mBAAmB,GACpB,EAAE;IACD,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB,EAAE,OAAO,CAAC;CAC9B,GAAG,OAAO,CAYV;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,SAAS,EACT,gBAAgB,EAChB,mBAAmB,GACpB,EAAE;IACD,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,gBAAgB,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IACnC,mBAAmB,EAAE,OAAO,CAAC;CAC9B,GAAG,OAAO,CAQV"}

package/dist/providerAvailability.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"providerAvailability.mjs","sourceRoot":"","sources":["../src/providerAvailability.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,qBAAqB,CAAC,OAAe;IACnD,MAAM,cAAc,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IACtC,OAAO,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC;QACtC,CAAC,CAAC,cAAc,CAAC,WAAW,EAAE;QAC9B,CAAC,CAAC,cAAc,CAAC;AACrB,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,mBAAmB,CACjC,QAAkB,EAClB,OAAe;IAEf,MAAM,GAAG,GAAG,QAAQ,EAAE,yBAAyB,CAAC;IAChD,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,MAAM,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC;IAC9C,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAC1B,CAAC,GAAG,EAAE,EAAE,CAAC,qBAAqB,CAAC,GAAG,CAAC,KAAK,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,CAC3D,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CACtC,SAAqB,EACrB,OAAe;IAEf,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,mBAAmB,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,yBAAyB,CAAC,EACxC,SAAS,EACT,OAAO,EACP,mBAAmB,GAKpB;IACC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,OAAO,GAAG,wBAAwB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IAC7D,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,EAAE,CAAC;QAC3D,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,CAAC,mBAAmB,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,sBAAsB,CAAC,EACrC,SAAS,EACT,gBAAgB,EAChB,mBAAmB,GAKpB;IACC,IAAI,gBAAgB,EAAE,IAAI,KAAK,QAAQ,EAAE,CAAC;QACxC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,CAAC,mBAAmB,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;AAC9B,CAAC","sourcesContent":["import type { Provider } from './RampsService.js';\n\n/**\n * Canonicalizes a CAIP-19 asset id for comparison against Ramps API values.\n *\n * CAIP-19 does not constrain the case of the asset reference, and the Ramps API\n * is not consistent about it. Every `eip155` key in `regions/{region}/providers`\n * `supportedCryptoCurrencies` is lowercase, while `regions/{region}/topTokens`\n * returns four mainnet `assetId` values EIP-55 checksummed (USDT, USDC, WBTC,\n * LINK) in both its `topTokens` and `allTokens` lists, with no lowercase\n * duplicate. Callers also supply checksummed ids of their own from other\n * controllers, so the two sides of a comparison can disagree on case for the\n * same asset.\n *\n * Non-EVM references are case-sensitive (Solana base58, Tron base58, bitcoin\n * bech32), so lowercasing is restricted to `eip155` rather than applied to the\n * whole string. This is a tightening: for EVM ids a plain `toLowerCase()` on\n * both sides already matched. Current API data carries non-EVM ids in identical\n * case on both endpoints, so the passthrough guards against future drift rather\n * than fixing an observed mismatch.\n *\n * The namespace itself is matched case-insensitively, so an `EIP155:` prefix\n * is treated as EVM even though CAIP-19 defines namespaces as lowercase.\n *\n * @param assetId - CAIP-19 asset id, in either case form.\n * @returns The asset id in the form the Ramps API uses.\n */\nexport function normalizeRampsAssetId(assetId: string): string {\n  const trimmedAssetId = assetId.trim();\n  return /^eip155:/iu.test(trimmedAssetId)\n    ? trimmedAssetId.toLowerCase()\n    : trimmedAssetId;\n}\n\n/**\n * Whether a provider serves the given deposit asset.\n *\n * Mirrors the region-provider matching the controller performs internally: a\n * provider serves the asset when its `supportedCryptoCurrencies` map (keyed by\n * CAIP-19 asset id) contains the asset id. Both sides are canonicalized with\n * {@link normalizeRampsAssetId}, so EVM ids match regardless of checksum\n * casing while non-EVM references stay case-sensitive. A provider without a\n * `supportedCryptoCurrencies` map is treated as not serving the asset.\n *\n * @param provider - The provider to test.\n * @param assetId - CAIP-19 asset id of the deposit asset.\n * @returns Whether the provider serves the asset.\n */\nexport function providerServesAsset(\n  provider: Provider,\n  assetId: string,\n): boolean {\n  const map = provider?.supportedCryptoCurrencies;\n  if (!map) {\n    return false;\n  }\n  const target = normalizeRampsAssetId(assetId);\n  return Object.keys(map).some(\n    (key) => normalizeRampsAssetId(key) === target && map[key],\n  );\n}\n\n/**\n * Filters a provider list down to those serving the given deposit asset.\n *\n * @param providers - The providers to filter.\n * @param assetId - CAIP-19 asset id of the deposit asset.\n * @returns The subset of providers serving the asset.\n */\nexport function getProvidersServingAsset(\n  providers: Provider[],\n  assetId: string,\n): Provider[] {\n  return providers.filter((provider) => providerServesAsset(provider, assetId));\n}\n\n/**\n * Whether a region offers a usable on-ramp provider that serves the given\n * deposit asset, under the all-providers feature flag. This is the pure,\n * asset-aware region gate shared between the controller and headless-buy\n * consumers so the two never disagree about eligibility.\n *\n * With `allProvidersEnabled` false the gate is native-only: the region must\n * offer a native provider (e.g. Transak Native) that serves the asset. With\n * `allProvidersEnabled` true the region is supported when any provider\n * (native or aggregator) serves the asset; the controller's flag-aware\n * `getQuotes` performs the precise provider selection at quote time. Fails\n * closed: an empty or missing `assetId` returns `false`.\n *\n * @param options - The options.\n * @param options.providers - The region's providers (native and aggregator).\n * @param options.assetId - CAIP-19 asset id of the deposit asset.\n * @param options.allProvidersEnabled - Whether the all-providers feature flag\n * is enabled (see `isHeadlessAllProvidersEnabled`).\n * @returns Whether the region has a provider serving the asset.\n */\nexport function regionHasProviderForAsset({\n  providers,\n  assetId,\n  allProvidersEnabled,\n}: {\n  providers: Provider[];\n  assetId: string;\n  allProvidersEnabled: boolean;\n}): boolean {\n  if (!assetId) {\n    return false;\n  }\n  const serving = getProvidersServingAsset(providers, assetId);\n  if (serving.some((provider) => provider.type === 'native')) {\n    return true;\n  }\n  if (!allProvidersEnabled) {\n    return false;\n  }\n  return serving.length > 0;\n}\n\n/**\n * Whether headless fiat deposit is available for the current region, under\n * the all-providers feature flag. Flag-aware and independent of which single\n * provider is currently selected once widened, so the availability gate\n * cannot disagree with the controller's own flag-aware provider pick.\n *\n * With `allProvidersEnabled` false the check keeps the native-only behaviour:\n * a native provider must be the currently selected (preferred) one, since the\n * controller resolves the selected provider first and an aggregator preferred\n * provider would otherwise run a non-native deposit. With\n * `allProvidersEnabled` true the flow is available whenever the region has\n * any provider.\n *\n * @param options - The options.\n * @param options.providers - The region's providers.\n * @param options.selectedProvider - The currently selected provider, if any.\n * @param options.allProvidersEnabled - Whether the all-providers feature flag\n * is enabled (see `isHeadlessAllProvidersEnabled`).\n * @returns Whether headless fiat deposit is available.\n */\nexport function isFiatDepositAvailable({\n  providers,\n  selectedProvider,\n  allProvidersEnabled,\n}: {\n  providers: Provider[];\n  selectedProvider?: Provider | null;\n  allProvidersEnabled: boolean;\n}): boolean {\n  if (selectedProvider?.type === 'native') {\n    return true;\n  }\n  if (!allProvidersEnabled) {\n    return false;\n  }\n  return providers.length > 0;\n}\n"]}

package/dist/quoteClassification.cjs

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isInAppOnlyQuote = exports.isCustomActionQuote = exports.isExternalBrowserQuote = void 0;
-/**
- * Whether a quote's checkout runs in an external / system browser rather than
- * an in-app WebView. Decided by the per-quote `buyWidget.browser` hint from the
- * quotes API. When the hint is absent the quote is treated as in-app (the
- * caller is responsible for the in-app WebView fail-safe).
- *
- * This is the pure classification only: it deliberately knows nothing about
- * host redirect URLs or deeplink schemes, which stay in the consuming client.
- *
- * @param quote - The quote to classify.
- * @returns Whether the quote uses an external browser.
- */
-function isExternalBrowserQuote(quote) {
-    return quote.quote?.buyWidget?.browser === 'IN_APP_OS_BROWSER';
-}
-exports.isExternalBrowserQuote = isExternalBrowserQuote;
-/**
- * Whether a quote is a custom-action ("checkout outside of MetaMask") quote,
- * e.g. PayPal or Robinhood. Reads the inline `isCustomAction` flag, which the
- * wire may carry even though it is absent from the published `Quote` type.
- *
- * @param quote - The quote to classify.
- * @returns Whether the quote is a custom-action quote.
- */
-function isCustomActionQuote(quote) {
-    return quote.quote?.isCustomAction === true;
-}
-exports.isCustomActionQuote = isCustomActionQuote;
-/**
- * Whether a quote continues inside an in-app WebView, i.e. it is neither a
- * custom-action quote nor an external-browser quote. This is the Phase 1
- * in-app-only inclusion test.
- *
- * @param quote - The quote to classify.
- * @returns Whether the quote is an in-app WebView quote.
- */
-function isInAppOnlyQuote(quote) {
-    return !isCustomActionQuote(quote) && !isExternalBrowserQuote(quote);
-}
-exports.isInAppOnlyQuote = isInAppOnlyQuote;
-//# sourceMappingURL=quoteClassification.cjs.map

package/dist/quoteClassification.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"quoteClassification.cjs","sourceRoot":"","sources":["../src/quoteClassification.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;GAWG;AACH,SAAgB,sBAAsB,CAAC,KAAY;IACjD,OAAO,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,KAAK,mBAAmB,CAAC;AACjE,CAAC;AAFD,wDAEC;AAED;;;;;;;GAOG;AACH,SAAgB,mBAAmB,CAAC,KAAY;IAC9C,OAAQ,KAAK,CAAC,KAAsC,EAAE,cAAc,KAAK,IAAI,CAAC;AAChF,CAAC;AAFD,kDAEC;AAED;;;;;;;GAOG;AACH,SAAgB,gBAAgB,CAAC,KAAY;IAC3C,OAAO,CAAC,mBAAmB,CAAC,KAAK,CAAC,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;AACvE,CAAC;AAFD,4CAEC","sourcesContent":["import type { Quote } from './RampsService.js';\n\n/**\n * Whether a quote's checkout runs in an external / system browser rather than\n * an in-app WebView. Decided by the per-quote `buyWidget.browser` hint from the\n * quotes API. When the hint is absent the quote is treated as in-app (the\n * caller is responsible for the in-app WebView fail-safe).\n *\n * This is the pure classification only: it deliberately knows nothing about\n * host redirect URLs or deeplink schemes, which stay in the consuming client.\n *\n * @param quote - The quote to classify.\n * @returns Whether the quote uses an external browser.\n */\nexport function isExternalBrowserQuote(quote: Quote): boolean {\n  return quote.quote?.buyWidget?.browser === 'IN_APP_OS_BROWSER';\n}\n\n/**\n * Whether a quote is a custom-action (\"checkout outside of MetaMask\") quote,\n * e.g. PayPal or Robinhood. Reads the inline `isCustomAction` flag, which the\n * wire may carry even though it is absent from the published `Quote` type.\n *\n * @param quote - The quote to classify.\n * @returns Whether the quote is a custom-action quote.\n */\nexport function isCustomActionQuote(quote: Quote): boolean {\n  return (quote.quote as { isCustomAction?: boolean })?.isCustomAction === true;\n}\n\n/**\n * Whether a quote continues inside an in-app WebView, i.e. it is neither a\n * custom-action quote nor an external-browser quote. This is the Phase 1\n * in-app-only inclusion test.\n *\n * @param quote - The quote to classify.\n * @returns Whether the quote is an in-app WebView quote.\n */\nexport function isInAppOnlyQuote(quote: Quote): boolean {\n  return !isCustomActionQuote(quote) && !isExternalBrowserQuote(quote);\n}\n"]}

package/dist/quoteClassification.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"quoteClassification.d.cts","sourceRoot":"","sources":["../src/quoteClassification.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,2BAA0B;AAE/C;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAE5D;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAEzD;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAEtD"}

package/dist/quoteClassification.d.mts

@@ -1,33 +0,0 @@
-import type { Quote } from "./RampsService.mjs";
-/**
- * Whether a quote's checkout runs in an external / system browser rather than
- * an in-app WebView. Decided by the per-quote `buyWidget.browser` hint from the
- * quotes API. When the hint is absent the quote is treated as in-app (the
- * caller is responsible for the in-app WebView fail-safe).
- *
- * This is the pure classification only: it deliberately knows nothing about
- * host redirect URLs or deeplink schemes, which stay in the consuming client.
- *
- * @param quote - The quote to classify.
- * @returns Whether the quote uses an external browser.
- */
-export declare function isExternalBrowserQuote(quote: Quote): boolean;
-/**
- * Whether a quote is a custom-action ("checkout outside of MetaMask") quote,
- * e.g. PayPal or Robinhood. Reads the inline `isCustomAction` flag, which the
- * wire may carry even though it is absent from the published `Quote` type.
- *
- * @param quote - The quote to classify.
- * @returns Whether the quote is a custom-action quote.
- */
-export declare function isCustomActionQuote(quote: Quote): boolean;
-/**
- * Whether a quote continues inside an in-app WebView, i.e. it is neither a
- * custom-action quote nor an external-browser quote. This is the Phase 1
- * in-app-only inclusion test.
- *
- * @param quote - The quote to classify.
- * @returns Whether the quote is an in-app WebView quote.
- */
-export declare function isInAppOnlyQuote(quote: Quote): boolean;
-//# sourceMappingURL=quoteClassification.d.mts.map

package/dist/quoteClassification.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"quoteClassification.d.mts","sourceRoot":"","sources":["../src/quoteClassification.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,2BAA0B;AAE/C;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAE5D;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAEzD;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAEtD"}

package/dist/quoteClassification.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"quoteClassification.mjs","sourceRoot":"","sources":["../src/quoteClassification.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAY;IACjD,OAAO,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,KAAK,mBAAmB,CAAC;AACjE,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAY;IAC9C,OAAQ,KAAK,CAAC,KAAsC,EAAE,cAAc,KAAK,IAAI,CAAC;AAChF,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAY;IAC3C,OAAO,CAAC,mBAAmB,CAAC,KAAK,CAAC,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;AACvE,CAAC","sourcesContent":["import type { Quote } from './RampsService.js';\n\n/**\n * Whether a quote's checkout runs in an external / system browser rather than\n * an in-app WebView. Decided by the per-quote `buyWidget.browser` hint from the\n * quotes API. When the hint is absent the quote is treated as in-app (the\n * caller is responsible for the in-app WebView fail-safe).\n *\n * This is the pure classification only: it deliberately knows nothing about\n * host redirect URLs or deeplink schemes, which stay in the consuming client.\n *\n * @param quote - The quote to classify.\n * @returns Whether the quote uses an external browser.\n */\nexport function isExternalBrowserQuote(quote: Quote): boolean {\n  return quote.quote?.buyWidget?.browser === 'IN_APP_OS_BROWSER';\n}\n\n/**\n * Whether a quote is a custom-action (\"checkout outside of MetaMask\") quote,\n * e.g. PayPal or Robinhood. Reads the inline `isCustomAction` flag, which the\n * wire may carry even though it is absent from the published `Quote` type.\n *\n * @param quote - The quote to classify.\n * @returns Whether the quote is a custom-action quote.\n */\nexport function isCustomActionQuote(quote: Quote): boolean {\n  return (quote.quote as { isCustomAction?: boolean })?.isCustomAction === true;\n}\n\n/**\n * Whether a quote continues inside an in-app WebView, i.e. it is neither a\n * custom-action quote nor an external-browser quote. This is the Phase 1\n * in-app-only inclusion test.\n *\n * @param quote - The quote to classify.\n * @returns Whether the quote is an in-app WebView quote.\n */\nexport function isInAppOnlyQuote(quote: Quote): boolean {\n  return !isCustomActionQuote(quote) && !isExternalBrowserQuote(quote);\n}\n"]}

package/dist/rampsErrorCodes.cjs

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RAMPS_ERROR_CODES = void 0;
-/**
- * Error codes for RampsController.
- * These codes are returned to the UI layer for translation.
- */
-exports.RAMPS_ERROR_CODES = {
-    CIRCUIT_BREAKER_OPEN: 'CIRCUIT_BREAKER_OPEN',
-};
-//# sourceMappingURL=rampsErrorCodes.cjs.map

package/dist/rampsErrorCodes.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"rampsErrorCodes.cjs","sourceRoot":"","sources":["../src/rampsErrorCodes.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACU,QAAA,iBAAiB,GAAG;IAC/B,oBAAoB,EAAE,sBAAsB;CACpC,CAAC","sourcesContent":["/**\n * Error codes for RampsController.\n * These codes are returned to the UI layer for translation.\n */\nexport const RAMPS_ERROR_CODES = {\n  CIRCUIT_BREAKER_OPEN: 'CIRCUIT_BREAKER_OPEN',\n} as const;\n\nexport type RampsErrorCode =\n  (typeof RAMPS_ERROR_CODES)[keyof typeof RAMPS_ERROR_CODES];\n"]}

package/dist/rampsErrorCodes.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rampsErrorCodes.d.cts","sourceRoot":"","sources":["../src/rampsErrorCodes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;CAEpB,CAAC;AAEX,MAAM,MAAM,cAAc,GACxB,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/rampsErrorCodes.d.mts

@@ -1,9 +0,0 @@
-/**
- * Error codes for RampsController.
- * These codes are returned to the UI layer for translation.
- */
-export declare const RAMPS_ERROR_CODES: {
-    readonly CIRCUIT_BREAKER_OPEN: "CIRCUIT_BREAKER_OPEN";
-};
-export type RampsErrorCode = (typeof RAMPS_ERROR_CODES)[keyof typeof RAMPS_ERROR_CODES];
-//# sourceMappingURL=rampsErrorCodes.d.mts.map

package/dist/rampsErrorCodes.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rampsErrorCodes.d.mts","sourceRoot":"","sources":["../src/rampsErrorCodes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;CAEpB,CAAC;AAEX,MAAM,MAAM,cAAc,GACxB,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/rampsErrorCodes.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"rampsErrorCodes.mjs","sourceRoot":"","sources":["../src/rampsErrorCodes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,oBAAoB,EAAE,sBAAsB;CACpC,CAAC","sourcesContent":["/**\n * Error codes for RampsController.\n * These codes are returned to the UI layer for translation.\n */\nexport const RAMPS_ERROR_CODES = {\n  CIRCUIT_BREAKER_OPEN: 'CIRCUIT_BREAKER_OPEN',\n} as const;\n\nexport type RampsErrorCode =\n  (typeof RAMPS_ERROR_CODES)[keyof typeof RAMPS_ERROR_CODES];\n"]}

package/dist/selectors.cjs

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRequestSelector = void 0;
-const RequestCache_js_1 = require("./RequestCache.cjs");
-/**
- * Creates a memoized selector for a controller method's request state.
- *
- * This selector tracks the loading, error, and data state for a specific
- * controller method call. It's optimized for use with React Redux's `useSelector`
- * hook - the selector returns the same object reference when the underlying
- * request state hasn't changed, so no `shallowEqual` is needed.
- *
- * The selector uses reference equality on the request object itself, so it
- * works correctly with arrays and objects without expensive deep equality checks.
- *
- * @param getState - Function that extracts RampsControllerState from the root state.
- *   Typically a reselect selector like `selectRampsControllerState`.
- * @param method - The controller method name (e.g., 'updateUserRegion').
- * @param params - The parameters passed to the method, used to generate the cache key.
- *   Must match the params used when calling the controller method.
- * @returns A selector function that returns `{ data, isFetching, error }`.
- *
- * @example
- * ```ts
- * // In selectors file - create once at module level
- * import { createRequestSelector } from '@metamask/ramps-controller';
- * import { createSelector } from 'reselect';
- *
- * const selectRampsControllerState = createSelector(
- *   (state: RootState) => state.engine.backgroundState.RampsController,
- *   (rampsControllerState) => rampsControllerState,
- * );
- *
- * export const selectUserRegionRequest = createRequestSelector<
- *   RootState,
- *   string
- * >(selectRampsControllerState, 'updateUserRegion', []);
- *
- * // In hook - use directly with useSelector, no shallowEqual needed
- * export function useRampsUserRegion() {
- *   const { isFetching, error } = useSelector(selectUserRegionRequest);
- *   // ... rest of hook
- * }
- * ```
- *
- * @example
- * ```ts
- * // For methods with parameters
- * export const selectCryptoCurrenciesRequest = (region: string) =>
- *   createRequestSelector<RootState, CryptoCurrency[]>(
- *     selectRampsControllerState,
- *     'getCryptoCurrencies',
- *     [region],
- *   );
- *
- * // In component
- * const { data, isFetching, error } = useSelector(
- *   selectCryptoCurrenciesRequest('US')
- * );
- * ```
- */
-function createRequestSelector(getState, method, params) {
-    const cacheKey = (0, RequestCache_js_1.createCacheKey)(method, params);
-    let lastRequest;
-    let lastResult = null;
-    return (state) => {
-        const request = getState(state)?.requests?.[cacheKey];
-        if (request === lastRequest && lastResult !== null) {
-            return lastResult;
-        }
-        lastRequest = request;
-        const nextResult = {
-            data: request?.data ?? null,
-            isFetching: request?.status === RequestCache_js_1.RequestStatus.LOADING,
-            error: request?.error ?? null,
-        };
-        if (request?.errorKey) {
-            nextResult.errorKey = request.errorKey;
-        }
-        lastResult = nextResult;
-        return lastResult;
-    };
-}
-exports.createRequestSelector = createRequestSelector;
-//# sourceMappingURL=selectors.cjs.map

package/dist/selectors.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"selectors.cjs","sourceRoot":"","sources":["../src/selectors.ts"],"names":[],"mappings":";;;AAGA,wDAAkE;AAoBlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,SAAgB,qBAAqB,CACnC,QAAqE,EACrE,MAAc,EACd,MAAiB;IAEjB,MAAM,QAAQ,GAAG,IAAA,gCAAc,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEhD,IAAI,WAAqC,CAAC;IAC1C,IAAI,UAAU,GAAwC,IAAI,CAAC;IAE3D,OAAO,CAAC,KAAiB,EAAgC,EAAE;QACzD,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC;QAEtD,IAAI,OAAO,KAAK,WAAW,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;YACnD,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,WAAW,GAAG,OAAO,CAAC;QACtB,MAAM,UAAU,GAAiC;YAC/C,IAAI,EAAG,OAAO,EAAE,IAAc,IAAI,IAAI;YACtC,UAAU,EAAE,OAAO,EAAE,MAAM,KAAK,+BAAa,CAAC,OAAO;YACrD,KAAK,EAAE,OAAO,EAAE,KAAK,IAAI,IAAI;SAC9B,CAAC;QAEF,IAAI,OAAO,EAAE,QAAQ,EAAE,CAAC;YACtB,UAAU,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;QACzC,CAAC;QAED,UAAU,GAAG,UAAU,CAAC;QAExB,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC;AAhCD,sDAgCC","sourcesContent":["import type { RampsControllerState } from './RampsController.js';\nimport type { RampsErrorCode } from './rampsErrorCodes.js';\nimport type { RequestState } from './RequestCache.js';\nimport { RequestStatus, createCacheKey } from './RequestCache.js';\n\n/**\n * Result shape returned by request selectors.\n *\n * This object is memoized - the same reference is returned when the underlying\n * request state hasn't changed, making it safe to use with React Redux's\n * `useSelector` without `shallowEqual`.\n */\nexport type RequestSelectorResult<TData> = {\n  /** The data returned by the request, or null if not yet loaded or on error. */\n  data: TData | null;\n  /** Whether the request is currently in progress. */\n  isFetching: boolean;\n  /** Error message if the request failed, or null if successful or not yet attempted. */\n  error: string | null;\n  /** Stable error key for client-side localization, if available. */\n  errorKey?: RampsErrorCode | null;\n};\n\n/**\n * Creates a memoized selector for a controller method's request state.\n *\n * This selector tracks the loading, error, and data state for a specific\n * controller method call. It's optimized for use with React Redux's `useSelector`\n * hook - the selector returns the same object reference when the underlying\n * request state hasn't changed, so no `shallowEqual` is needed.\n *\n * The selector uses reference equality on the request object itself, so it\n * works correctly with arrays and objects without expensive deep equality checks.\n *\n * @param getState - Function that extracts RampsControllerState from the root state.\n *   Typically a reselect selector like `selectRampsControllerState`.\n * @param method - The controller method name (e.g., 'updateUserRegion').\n * @param params - The parameters passed to the method, used to generate the cache key.\n *   Must match the params used when calling the controller method.\n * @returns A selector function that returns `{ data, isFetching, error }`.\n *\n * @example\n * ```ts\n * // In selectors file - create once at module level\n * import { createRequestSelector } from '@metamask/ramps-controller';\n * import { createSelector } from 'reselect';\n *\n * const selectRampsControllerState = createSelector(\n *   (state: RootState) => state.engine.backgroundState.RampsController,\n *   (rampsControllerState) => rampsControllerState,\n * );\n *\n * export const selectUserRegionRequest = createRequestSelector<\n *   RootState,\n *   string\n * >(selectRampsControllerState, 'updateUserRegion', []);\n *\n * // In hook - use directly with useSelector, no shallowEqual needed\n * export function useRampsUserRegion() {\n *   const { isFetching, error } = useSelector(selectUserRegionRequest);\n *   // ... rest of hook\n * }\n * ```\n *\n * @example\n * ```ts\n * // For methods with parameters\n * export const selectCryptoCurrenciesRequest = (region: string) =>\n *   createRequestSelector<RootState, CryptoCurrency[]>(\n *     selectRampsControllerState,\n *     'getCryptoCurrencies',\n *     [region],\n *   );\n *\n * // In component\n * const { data, isFetching, error } = useSelector(\n *   selectCryptoCurrenciesRequest('US')\n * );\n * ```\n */\nexport function createRequestSelector<TRootState, TData>(\n  getState: (rootState: TRootState) => RampsControllerState | undefined,\n  method: string,\n  params: unknown[],\n): (state: TRootState) => RequestSelectorResult<TData> {\n  const cacheKey = createCacheKey(method, params);\n\n  let lastRequest: RequestState | undefined;\n  let lastResult: RequestSelectorResult<TData> | null = null;\n\n  return (state: TRootState): RequestSelectorResult<TData> => {\n    const request = getState(state)?.requests?.[cacheKey];\n\n    if (request === lastRequest && lastResult !== null) {\n      return lastResult;\n    }\n\n    lastRequest = request;\n    const nextResult: RequestSelectorResult<TData> = {\n      data: (request?.data as TData) ?? null,\n      isFetching: request?.status === RequestStatus.LOADING,\n      error: request?.error ?? null,\n    };\n\n    if (request?.errorKey) {\n      nextResult.errorKey = request.errorKey;\n    }\n\n    lastResult = nextResult;\n\n    return lastResult;\n  };\n}\n"]}

package/dist/selectors.d.cts

@@ -1,78 +0,0 @@
-import type { RampsControllerState } from "./RampsController.cjs";
-import type { RampsErrorCode } from "./rampsErrorCodes.cjs";
-/**
- * Result shape returned by request selectors.
- *
- * This object is memoized - the same reference is returned when the underlying
- * request state hasn't changed, making it safe to use with React Redux's
- * `useSelector` without `shallowEqual`.
- */
-export type RequestSelectorResult<TData> = {
-    /** The data returned by the request, or null if not yet loaded or on error. */
-    data: TData | null;
-    /** Whether the request is currently in progress. */
-    isFetching: boolean;
-    /** Error message if the request failed, or null if successful or not yet attempted. */
-    error: string | null;
-    /** Stable error key for client-side localization, if available. */
-    errorKey?: RampsErrorCode | null;
-};
-/**
- * Creates a memoized selector for a controller method's request state.
- *
- * This selector tracks the loading, error, and data state for a specific
- * controller method call. It's optimized for use with React Redux's `useSelector`
- * hook - the selector returns the same object reference when the underlying
- * request state hasn't changed, so no `shallowEqual` is needed.
- *
- * The selector uses reference equality on the request object itself, so it
- * works correctly with arrays and objects without expensive deep equality checks.
- *
- * @param getState - Function that extracts RampsControllerState from the root state.
- *   Typically a reselect selector like `selectRampsControllerState`.
- * @param method - The controller method name (e.g., 'updateUserRegion').
- * @param params - The parameters passed to the method, used to generate the cache key.
- *   Must match the params used when calling the controller method.
- * @returns A selector function that returns `{ data, isFetching, error }`.
- *
- * @example
- * ```ts
- * // In selectors file - create once at module level
- * import { createRequestSelector } from '@metamask/ramps-controller';
- * import { createSelector } from 'reselect';
- *
- * const selectRampsControllerState = createSelector(
- *   (state: RootState) => state.engine.backgroundState.RampsController,
- *   (rampsControllerState) => rampsControllerState,
- * );
- *
- * export const selectUserRegionRequest = createRequestSelector<
- *   RootState,
- *   string
- * >(selectRampsControllerState, 'updateUserRegion', []);
- *
- * // In hook - use directly with useSelector, no shallowEqual needed
- * export function useRampsUserRegion() {
- *   const { isFetching, error } = useSelector(selectUserRegionRequest);
- *   // ... rest of hook
- * }
- * ```
- *
- * @example
- * ```ts
- * // For methods with parameters
- * export const selectCryptoCurrenciesRequest = (region: string) =>
- *   createRequestSelector<RootState, CryptoCurrency[]>(
- *     selectRampsControllerState,
- *     'getCryptoCurrencies',
- *     [region],
- *   );
- *
- * // In component
- * const { data, isFetching, error } = useSelector(
- *   selectCryptoCurrenciesRequest('US')
- * );
- * ```
- */
-export declare function createRequestSelector<TRootState, TData>(getState: (rootState: TRootState) => RampsControllerState | undefined, method: string, params: unknown[]): (state: TRootState) => RequestSelectorResult<TData>;
-//# sourceMappingURL=selectors.d.cts.map

package/dist/selectors.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"selectors.d.cts","sourceRoot":"","sources":["../src/selectors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,8BAA6B;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,8BAA6B;AAI3D;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,CAAC,KAAK,IAAI;IACzC,+EAA+E;IAC/E,IAAI,EAAE,KAAK,GAAG,IAAI,CAAC;IACnB,oDAAoD;IACpD,UAAU,EAAE,OAAO,CAAC;IACpB,uFAAuF;IACvF,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;CAClC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,KAAK,EACrD,QAAQ,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,oBAAoB,GAAG,SAAS,EACrE,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,EAAE,GAChB,CAAC,KAAK,EAAE,UAAU,KAAK,qBAAqB,CAAC,KAAK,CAAC,CA4BrD"}

package/dist/selectors.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"selectors.d.mts","sourceRoot":"","sources":["../src/selectors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,8BAA6B;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,8BAA6B;AAI3D;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,CAAC,KAAK,IAAI;IACzC,+EAA+E;IAC/E,IAAI,EAAE,KAAK,GAAG,IAAI,CAAC;IACnB,oDAAoD;IACpD,UAAU,EAAE,OAAO,CAAC;IACpB,uFAAuF;IACvF,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;CAClC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,KAAK,EACrD,QAAQ,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,oBAAoB,GAAG,SAAS,EACrE,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,EAAE,GAChB,CAAC,KAAK,EAAE,UAAU,KAAK,qBAAqB,CAAC,KAAK,CAAC,CA4BrD"}

package/dist/selectors.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"selectors.mjs","sourceRoot":"","sources":["../src/selectors.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,2BAA0B;AAoBlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,MAAM,UAAU,qBAAqB,CACnC,QAAqE,EACrE,MAAc,EACd,MAAiB;IAEjB,MAAM,QAAQ,GAAG,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEhD,IAAI,WAAqC,CAAC;IAC1C,IAAI,UAAU,GAAwC,IAAI,CAAC;IAE3D,OAAO,CAAC,KAAiB,EAAgC,EAAE;QACzD,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC;QAEtD,IAAI,OAAO,KAAK,WAAW,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;YACnD,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,WAAW,GAAG,OAAO,CAAC;QACtB,MAAM,UAAU,GAAiC;YAC/C,IAAI,EAAG,OAAO,EAAE,IAAc,IAAI,IAAI;YACtC,UAAU,EAAE,OAAO,EAAE,MAAM,KAAK,aAAa,CAAC,OAAO;YACrD,KAAK,EAAE,OAAO,EAAE,KAAK,IAAI,IAAI;SAC9B,CAAC;QAEF,IAAI,OAAO,EAAE,QAAQ,EAAE,CAAC;YACtB,UAAU,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;QACzC,CAAC;QAED,UAAU,GAAG,UAAU,CAAC;QAExB,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import type { RampsControllerState } from './RampsController.js';\nimport type { RampsErrorCode } from './rampsErrorCodes.js';\nimport type { RequestState } from './RequestCache.js';\nimport { RequestStatus, createCacheKey } from './RequestCache.js';\n\n/**\n * Result shape returned by request selectors.\n *\n * This object is memoized - the same reference is returned when the underlying\n * request state hasn't changed, making it safe to use with React Redux's\n * `useSelector` without `shallowEqual`.\n */\nexport type RequestSelectorResult<TData> = {\n  /** The data returned by the request, or null if not yet loaded or on error. */\n  data: TData | null;\n  /** Whether the request is currently in progress. */\n  isFetching: boolean;\n  /** Error message if the request failed, or null if successful or not yet attempted. */\n  error: string | null;\n  /** Stable error key for client-side localization, if available. */\n  errorKey?: RampsErrorCode | null;\n};\n\n/**\n * Creates a memoized selector for a controller method's request state.\n *\n * This selector tracks the loading, error, and data state for a specific\n * controller method call. It's optimized for use with React Redux's `useSelector`\n * hook - the selector returns the same object reference when the underlying\n * request state hasn't changed, so no `shallowEqual` is needed.\n *\n * The selector uses reference equality on the request object itself, so it\n * works correctly with arrays and objects without expensive deep equality checks.\n *\n * @param getState - Function that extracts RampsControllerState from the root state.\n *   Typically a reselect selector like `selectRampsControllerState`.\n * @param method - The controller method name (e.g., 'updateUserRegion').\n * @param params - The parameters passed to the method, used to generate the cache key.\n *   Must match the params used when calling the controller method.\n * @returns A selector function that returns `{ data, isFetching, error }`.\n *\n * @example\n * ```ts\n * // In selectors file - create once at module level\n * import { createRequestSelector } from '@metamask/ramps-controller';\n * import { createSelector } from 'reselect';\n *\n * const selectRampsControllerState = createSelector(\n *   (state: RootState) => state.engine.backgroundState.RampsController,\n *   (rampsControllerState) => rampsControllerState,\n * );\n *\n * export const selectUserRegionRequest = createRequestSelector<\n *   RootState,\n *   string\n * >(selectRampsControllerState, 'updateUserRegion', []);\n *\n * // In hook - use directly with useSelector, no shallowEqual needed\n * export function useRampsUserRegion() {\n *   const { isFetching, error } = useSelector(selectUserRegionRequest);\n *   // ... rest of hook\n * }\n * ```\n *\n * @example\n * ```ts\n * // For methods with parameters\n * export const selectCryptoCurrenciesRequest = (region: string) =>\n *   createRequestSelector<RootState, CryptoCurrency[]>(\n *     selectRampsControllerState,\n *     'getCryptoCurrencies',\n *     [region],\n *   );\n *\n * // In component\n * const { data, isFetching, error } = useSelector(\n *   selectCryptoCurrenciesRequest('US')\n * );\n * ```\n */\nexport function createRequestSelector<TRootState, TData>(\n  getState: (rootState: TRootState) => RampsControllerState | undefined,\n  method: string,\n  params: unknown[],\n): (state: TRootState) => RequestSelectorResult<TData> {\n  const cacheKey = createCacheKey(method, params);\n\n  let lastRequest: RequestState | undefined;\n  let lastResult: RequestSelectorResult<TData> | null = null;\n\n  return (state: TRootState): RequestSelectorResult<TData> => {\n    const request = getState(state)?.requests?.[cacheKey];\n\n    if (request === lastRequest && lastResult !== null) {\n      return lastResult;\n    }\n\n    lastRequest = request;\n    const nextResult: RequestSelectorResult<TData> = {\n      data: (request?.data as TData) ?? null,\n      isFetching: request?.status === RequestStatus.LOADING,\n      error: request?.error ?? null,\n    };\n\n    if (request?.errorKey) {\n      nextResult.errorKey = request.errorKey;\n    }\n\n    lastResult = nextResult;\n\n    return lastResult;\n  };\n}\n"]}