@metamask/ramps-controller 19.0.0 → 20.1.0

package/dist/orderStatus.d.cts

@@ -0,0 +1,18 @@
+import { RampsOrderStatus } from "./RampsService.cjs";
+/**
+ * Order statuses that no longer require polling or in-flow navigation.
+ * Shared by the controller and consuming clients so terminal checks stay in sync.
+ */
+export declare const TERMINAL_ORDER_STATUSES: ReadonlySet<RampsOrderStatus>;
+/**
+ * Whether a ramps order has reached a terminal status.
+ *
+ * @param status - The order status to test.
+ * @returns Whether the status is terminal.
+ */
+export declare function isTerminalOrderStatus(status: RampsOrderStatus): boolean;
+/**
+ * Order statuses that are still in progress and may be polled.
+ */
+export declare const PENDING_ORDER_STATUSES: ReadonlySet<RampsOrderStatus>;
+//# sourceMappingURL=orderStatus.d.cts.map

package/dist/orderStatus.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orderStatus.d.cts","sourceRoot":"","sources":["../src/orderStatus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,2BAA0B;AAErD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,gBAAgB,CAKhE,CAAC;AAEH;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAEvE;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,gBAAgB,CAK/D,CAAC"}

package/dist/orderStatus.d.mts

@@ -0,0 +1,18 @@
+import { RampsOrderStatus } from "./RampsService.mjs";
+/**
+ * Order statuses that no longer require polling or in-flow navigation.
+ * Shared by the controller and consuming clients so terminal checks stay in sync.
+ */
+export declare const TERMINAL_ORDER_STATUSES: ReadonlySet<RampsOrderStatus>;
+/**
+ * Whether a ramps order has reached a terminal status.
+ *
+ * @param status - The order status to test.
+ * @returns Whether the status is terminal.
+ */
+export declare function isTerminalOrderStatus(status: RampsOrderStatus): boolean;
+/**
+ * Order statuses that are still in progress and may be polled.
+ */
+export declare const PENDING_ORDER_STATUSES: ReadonlySet<RampsOrderStatus>;
+//# sourceMappingURL=orderStatus.d.mts.map

package/dist/orderStatus.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orderStatus.d.mts","sourceRoot":"","sources":["../src/orderStatus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,2BAA0B;AAErD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,gBAAgB,CAKhE,CAAC;AAEH;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAEvE;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,gBAAgB,CAK/D,CAAC"}

package/dist/orderStatus.mjs

@@ -0,0 +1,30 @@
+import { RampsOrderStatus } from "./RampsService.mjs";
+/**
+ * Order statuses that no longer require polling or in-flow navigation.
+ * Shared by the controller and consuming clients so terminal checks stay in sync.
+ */
+export const TERMINAL_ORDER_STATUSES = new Set([
+    RampsOrderStatus.Completed,
+    RampsOrderStatus.Failed,
+    RampsOrderStatus.Cancelled,
+    RampsOrderStatus.IdExpired,
+]);
+/**
+ * Whether a ramps order has reached a terminal status.
+ *
+ * @param status - The order status to test.
+ * @returns Whether the status is terminal.
+ */
+export function isTerminalOrderStatus(status) {
+    return TERMINAL_ORDER_STATUSES.has(status);
+}
+/**
+ * Order statuses that are still in progress and may be polled.
+ */
+export const PENDING_ORDER_STATUSES = new Set([
+    RampsOrderStatus.Pending,
+    RampsOrderStatus.Created,
+    RampsOrderStatus.Unknown,
+    RampsOrderStatus.Precreated,
+]);
+//# sourceMappingURL=orderStatus.mjs.map

package/dist/orderStatus.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"orderStatus.mjs","sourceRoot":"","sources":["../src/orderStatus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,2BAA0B;AAErD;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAkC,IAAI,GAAG,CAAC;IAC5E,gBAAgB,CAAC,SAAS;IAC1B,gBAAgB,CAAC,MAAM;IACvB,gBAAgB,CAAC,SAAS;IAC1B,gBAAgB,CAAC,SAAS;CAC3B,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,MAAwB;IAC5D,OAAO,uBAAuB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;AAC7C,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAkC,IAAI,GAAG,CAAC;IAC3E,gBAAgB,CAAC,OAAO;IACxB,gBAAgB,CAAC,OAAO;IACxB,gBAAgB,CAAC,OAAO;IACxB,gBAAgB,CAAC,UAAU;CAC5B,CAAC,CAAC","sourcesContent":["import { RampsOrderStatus } from './RampsService.js';\n\n/**\n * Order statuses that no longer require polling or in-flow navigation.\n * Shared by the controller and consuming clients so terminal checks stay in sync.\n */\nexport const TERMINAL_ORDER_STATUSES: ReadonlySet<RampsOrderStatus> = new Set([\n  RampsOrderStatus.Completed,\n  RampsOrderStatus.Failed,\n  RampsOrderStatus.Cancelled,\n  RampsOrderStatus.IdExpired,\n]);\n\n/**\n * Whether a ramps order has reached a terminal status.\n *\n * @param status - The order status to test.\n * @returns Whether the status is terminal.\n */\nexport function isTerminalOrderStatus(status: RampsOrderStatus): boolean {\n  return TERMINAL_ORDER_STATUSES.has(status);\n}\n\n/**\n * Order statuses that are still in progress and may be polled.\n */\nexport const PENDING_ORDER_STATUSES: ReadonlySet<RampsOrderStatus> = new Set([\n  RampsOrderStatus.Pending,\n  RampsOrderStatus.Created,\n  RampsOrderStatus.Unknown,\n  RampsOrderStatus.Precreated,\n]);\n"]}

package/dist/paymentMethodMerge.cjs

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergePaymentMethodsById = exports.pickPaymentMethod = void 0;
+/**
+ * Merges payment-method lists from multiple providers into one list keyed by
+ * canonical payment method `id`.
+ *
+ * First seen wins on collision. Payment metadata is provider-invariant: the
+ * API serves it from a per-region catalog and the `provider` query narrows
+ * that catalog by id-set membership without rewriting fields, so colliding
+ * entries carry identical values.
+ *
+ * Encounter order of first-seen ids is preserved (provider fan-out order).
+ *
+ * @param lists - Payment method arrays in provider contribution order.
+ * @returns Deduped payment methods.
+ */
+/**
+ * Picks the payment method to select: the first `preferredIds` entry still
+ * present in `methods`, otherwise the first method.
+ *
+ * @param methods - Candidate payment methods, in display order.
+ * @param preferredIds - Preferred ids in priority order; falsy ids are skipped.
+ * @returns The selection, or null when `methods` is empty.
+ */
+function pickPaymentMethod(methods, preferredIds) {
+    for (const id of preferredIds) {
+        const match = id ? methods.find((method) => method.id === id) : undefined;
+        if (match) {
+            return match;
+        }
+    }
+    return methods[0] ?? null;
+}
+exports.pickPaymentMethod = pickPaymentMethod;
+function mergePaymentMethodsById(lists) {
+    if (lists.length === 1) {
+        return lists[0];
+    }
+    const byId = new Map();
+    for (const list of lists) {
+        for (const method of list) {
+            if (!byId.has(method.id)) {
+                byId.set(method.id, { ...method });
+            }
+        }
+    }
+    return [...byId.values()];
+}
+exports.mergePaymentMethodsById = mergePaymentMethodsById;
+//# sourceMappingURL=paymentMethodMerge.cjs.map

package/dist/paymentMethodMerge.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"paymentMethodMerge.cjs","sourceRoot":"","sources":["../src/paymentMethodMerge.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;GAaG;AACH;;;;;;;GAOG;AACH,SAAgB,iBAAiB,CAC/B,OAAwB,EACxB,YAAoC;IAEpC,KAAK,MAAM,EAAE,IAAI,YAAY,EAAE,CAAC;QAC9B,MAAM,KAAK,GAAG,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC1E,IAAI,KAAK,EAAE,CAAC;YACV,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;AAC5B,CAAC;AAXD,8CAWC;AAED,SAAgB,uBAAuB,CACrC,KAAwB;IAExB,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,GAAG,EAAyB,CAAC;IAE9C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,KAAK,MAAM,MAAM,IAAI,IAAI,EAAE,CAAC;YAC1B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC;gBACzB,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;YACrC,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;AAC5B,CAAC;AAlBD,0DAkBC","sourcesContent":["import type { PaymentMethod } from './RampsService.js';\n\n/**\n * Merges payment-method lists from multiple providers into one list keyed by\n * canonical payment method `id`.\n *\n * First seen wins on collision. Payment metadata is provider-invariant: the\n * API serves it from a per-region catalog and the `provider` query narrows\n * that catalog by id-set membership without rewriting fields, so colliding\n * entries carry identical values.\n *\n * Encounter order of first-seen ids is preserved (provider fan-out order).\n *\n * @param lists - Payment method arrays in provider contribution order.\n * @returns Deduped payment methods.\n */\n/**\n * Picks the payment method to select: the first `preferredIds` entry still\n * present in `methods`, otherwise the first method.\n *\n * @param methods - Candidate payment methods, in display order.\n * @param preferredIds - Preferred ids in priority order; falsy ids are skipped.\n * @returns The selection, or null when `methods` is empty.\n */\nexport function pickPaymentMethod(\n  methods: PaymentMethod[],\n  preferredIds: (string | undefined)[],\n): PaymentMethod | null {\n  for (const id of preferredIds) {\n    const match = id ? methods.find((method) => method.id === id) : undefined;\n    if (match) {\n      return match;\n    }\n  }\n  return methods[0] ?? null;\n}\n\nexport function mergePaymentMethodsById(\n  lists: PaymentMethod[][],\n): PaymentMethod[] {\n  if (lists.length === 1) {\n    return lists[0];\n  }\n\n  const byId = new Map<string, PaymentMethod>();\n\n  for (const list of lists) {\n    for (const method of list) {\n      if (!byId.has(method.id)) {\n        byId.set(method.id, { ...method });\n      }\n    }\n  }\n\n  return [...byId.values()];\n}\n"]}

package/dist/paymentMethodMerge.d.cts

@@ -0,0 +1,26 @@
+import type { PaymentMethod } from "./RampsService.cjs";
+/**
+ * Merges payment-method lists from multiple providers into one list keyed by
+ * canonical payment method `id`.
+ *
+ * First seen wins on collision. Payment metadata is provider-invariant: the
+ * API serves it from a per-region catalog and the `provider` query narrows
+ * that catalog by id-set membership without rewriting fields, so colliding
+ * entries carry identical values.
+ *
+ * Encounter order of first-seen ids is preserved (provider fan-out order).
+ *
+ * @param lists - Payment method arrays in provider contribution order.
+ * @returns Deduped payment methods.
+ */
+/**
+ * Picks the payment method to select: the first `preferredIds` entry still
+ * present in `methods`, otherwise the first method.
+ *
+ * @param methods - Candidate payment methods, in display order.
+ * @param preferredIds - Preferred ids in priority order; falsy ids are skipped.
+ * @returns The selection, or null when `methods` is empty.
+ */
+export declare function pickPaymentMethod(methods: PaymentMethod[], preferredIds: (string | undefined)[]): PaymentMethod | null;
+export declare function mergePaymentMethodsById(lists: PaymentMethod[][]): PaymentMethod[];
+//# sourceMappingURL=paymentMethodMerge.d.cts.map

package/dist/paymentMethodMerge.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paymentMethodMerge.d.cts","sourceRoot":"","sources":["../src/paymentMethodMerge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,2BAA0B;AAEvD;;;;;;;;;;;;;GAaG;AACH;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,aAAa,EAAE,EACxB,YAAY,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,GACnC,aAAa,GAAG,IAAI,CAQtB;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,aAAa,EAAE,EAAE,GACvB,aAAa,EAAE,CAgBjB"}

package/dist/paymentMethodMerge.d.mts

@@ -0,0 +1,26 @@
+import type { PaymentMethod } from "./RampsService.mjs";
+/**
+ * Merges payment-method lists from multiple providers into one list keyed by
+ * canonical payment method `id`.
+ *
+ * First seen wins on collision. Payment metadata is provider-invariant: the
+ * API serves it from a per-region catalog and the `provider` query narrows
+ * that catalog by id-set membership without rewriting fields, so colliding
+ * entries carry identical values.
+ *
+ * Encounter order of first-seen ids is preserved (provider fan-out order).
+ *
+ * @param lists - Payment method arrays in provider contribution order.
+ * @returns Deduped payment methods.
+ */
+/**
+ * Picks the payment method to select: the first `preferredIds` entry still
+ * present in `methods`, otherwise the first method.
+ *
+ * @param methods - Candidate payment methods, in display order.
+ * @param preferredIds - Preferred ids in priority order; falsy ids are skipped.
+ * @returns The selection, or null when `methods` is empty.
+ */
+export declare function pickPaymentMethod(methods: PaymentMethod[], preferredIds: (string | undefined)[]): PaymentMethod | null;
+export declare function mergePaymentMethodsById(lists: PaymentMethod[][]): PaymentMethod[];
+//# sourceMappingURL=paymentMethodMerge.d.mts.map

package/dist/paymentMethodMerge.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paymentMethodMerge.d.mts","sourceRoot":"","sources":["../src/paymentMethodMerge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,2BAA0B;AAEvD;;;;;;;;;;;;;GAaG;AACH;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,aAAa,EAAE,EACxB,YAAY,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,GACnC,aAAa,GAAG,IAAI,CAQtB;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,aAAa,EAAE,EAAE,GACvB,aAAa,EAAE,CAgBjB"}

package/dist/paymentMethodMerge.mjs

@@ -0,0 +1,46 @@
+/**
+ * Merges payment-method lists from multiple providers into one list keyed by
+ * canonical payment method `id`.
+ *
+ * First seen wins on collision. Payment metadata is provider-invariant: the
+ * API serves it from a per-region catalog and the `provider` query narrows
+ * that catalog by id-set membership without rewriting fields, so colliding
+ * entries carry identical values.
+ *
+ * Encounter order of first-seen ids is preserved (provider fan-out order).
+ *
+ * @param lists - Payment method arrays in provider contribution order.
+ * @returns Deduped payment methods.
+ */
+/**
+ * Picks the payment method to select: the first `preferredIds` entry still
+ * present in `methods`, otherwise the first method.
+ *
+ * @param methods - Candidate payment methods, in display order.
+ * @param preferredIds - Preferred ids in priority order; falsy ids are skipped.
+ * @returns The selection, or null when `methods` is empty.
+ */
+export function pickPaymentMethod(methods, preferredIds) {
+    for (const id of preferredIds) {
+        const match = id ? methods.find((method) => method.id === id) : undefined;
+        if (match) {
+            return match;
+        }
+    }
+    return methods[0] ?? null;
+}
+export function mergePaymentMethodsById(lists) {
+    if (lists.length === 1) {
+        return lists[0];
+    }
+    const byId = new Map();
+    for (const list of lists) {
+        for (const method of list) {
+            if (!byId.has(method.id)) {
+                byId.set(method.id, { ...method });
+            }
+        }
+    }
+    return [...byId.values()];
+}
+//# sourceMappingURL=paymentMethodMerge.mjs.map

package/dist/paymentMethodMerge.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"paymentMethodMerge.mjs","sourceRoot":"","sources":["../src/paymentMethodMerge.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAAwB,EACxB,YAAoC;IAEpC,KAAK,MAAM,EAAE,IAAI,YAAY,EAAE,CAAC;QAC9B,MAAM,KAAK,GAAG,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC1E,IAAI,KAAK,EAAE,CAAC;YACV,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;AAC5B,CAAC;AAED,MAAM,UAAU,uBAAuB,CACrC,KAAwB;IAExB,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,GAAG,EAAyB,CAAC;IAE9C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,KAAK,MAAM,MAAM,IAAI,IAAI,EAAE,CAAC;YAC1B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC;gBACzB,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;YACrC,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;AAC5B,CAAC","sourcesContent":["import type { PaymentMethod } from './RampsService.js';\n\n/**\n * Merges payment-method lists from multiple providers into one list keyed by\n * canonical payment method `id`.\n *\n * First seen wins on collision. Payment metadata is provider-invariant: the\n * API serves it from a per-region catalog and the `provider` query narrows\n * that catalog by id-set membership without rewriting fields, so colliding\n * entries carry identical values.\n *\n * Encounter order of first-seen ids is preserved (provider fan-out order).\n *\n * @param lists - Payment method arrays in provider contribution order.\n * @returns Deduped payment methods.\n */\n/**\n * Picks the payment method to select: the first `preferredIds` entry still\n * present in `methods`, otherwise the first method.\n *\n * @param methods - Candidate payment methods, in display order.\n * @param preferredIds - Preferred ids in priority order; falsy ids are skipped.\n * @returns The selection, or null when `methods` is empty.\n */\nexport function pickPaymentMethod(\n  methods: PaymentMethod[],\n  preferredIds: (string | undefined)[],\n): PaymentMethod | null {\n  for (const id of preferredIds) {\n    const match = id ? methods.find((method) => method.id === id) : undefined;\n    if (match) {\n      return match;\n    }\n  }\n  return methods[0] ?? null;\n}\n\nexport function mergePaymentMethodsById(\n  lists: PaymentMethod[][],\n): PaymentMethod[] {\n  if (lists.length === 1) {\n    return lists[0];\n  }\n\n  const byId = new Map<string, PaymentMethod>();\n\n  for (const list of lists) {\n    for (const method of list) {\n      if (!byId.has(method.id)) {\n        byId.set(method.id, { ...method });\n      }\n    }\n  }\n\n  return [...byId.values()];\n}\n"]}

package/dist/providerAvailability.cjs

@@ -1,16 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFiatDepositAvailable = exports.regionHasProviderForAsset = exports.getProvidersServingAsset = exports.providerServesAsset = void 0;
+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, compared case-insensitively on both
- * sides. EVM CAIP-19 asset ids may arrive checksummed or lowercased and the
- * providers API returns both forms, so only the lowercased forms are compared.
- * A provider without a `supportedCryptoCurrencies` map is treated as not
- * serving the asset.
+ * 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.
@@ -21,8 +52,8 @@ function providerServesAsset(provider, assetId) {
     if (!map) {
         return false;
     }
-    const target = assetId.toLowerCase();
-    return Object.keys(map).some((key) => key.toLowerCase() === target && map[key]);
+    const target = normalizeRampsAssetId(assetId);
+    return Object.keys(map).some((key) => normalizeRampsAssetId(key) === target && map[key]);
 }
 exports.providerServesAsset = providerServesAsset;
 /**

package/dist/providerAvailability.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"providerAvailability.cjs","sourceRoot":"","sources":["../src/providerAvailability.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;GAcG;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,OAAO,CAAC,WAAW,EAAE,CAAC;IACrC,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAC1B,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,CAClD,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 * 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, compared case-insensitively on both\n * sides. EVM CAIP-19 asset ids may arrive checksummed or lowercased and the\n * providers API returns both forms, so only the lowercased forms are compared.\n * A provider without a `supportedCryptoCurrencies` map is treated as not\n * 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 = assetId.toLowerCase();\n  return Object.keys(map).some(\n    (key) => key.toLowerCase() === 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"]}
+{"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,14 +1,39 @@
 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, compared case-insensitively on both
- * sides. EVM CAIP-19 asset ids may arrive checksummed or lowercased and the
- * providers API returns both forms, so only the lowercased forms are compared.
- * A provider without a `supportedCryptoCurrencies` map is treated as not
- * serving the asset.
+ * 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.

package/dist/providerAvailability.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"providerAvailability.d.cts","sourceRoot":"","sources":["../src/providerAvailability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,2BAA0B;AAElD;;;;;;;;;;;;;;GAcG;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"}
+{"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

@@ -1,14 +1,39 @@
 import type { Provider } from "./RampsService.mjs";
+/**
+ * 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, compared case-insensitively on both
- * sides. EVM CAIP-19 asset ids may arrive checksummed or lowercased and the
- * providers API returns both forms, so only the lowercased forms are compared.
- * A provider without a `supportedCryptoCurrencies` map is treated as not
- * serving the asset.
+ * 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.

package/dist/providerAvailability.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"providerAvailability.d.mts","sourceRoot":"","sources":["../src/providerAvailability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,2BAA0B;AAElD;;;;;;;;;;;;;;GAcG;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"}
+{"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

@@ -1,13 +1,43 @@
+/**
+ * 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 function normalizeRampsAssetId(assetId) {
+    const trimmedAssetId = assetId.trim();
+    return /^eip155:/iu.test(trimmedAssetId)
+        ? trimmedAssetId.toLowerCase()
+        : trimmedAssetId;
+}
 /**
  * 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, compared case-insensitively on both
- * sides. EVM CAIP-19 asset ids may arrive checksummed or lowercased and the
- * providers API returns both forms, so only the lowercased forms are compared.
- * A provider without a `supportedCryptoCurrencies` map is treated as not
- * serving the asset.
+ * 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.
@@ -18,8 +48,8 @@ export function providerServesAsset(provider, assetId) {
     if (!map) {
         return false;
     }
-    const target = assetId.toLowerCase();
-    return Object.keys(map).some((key) => key.toLowerCase() === target && map[key]);
+    const target = normalizeRampsAssetId(assetId);
+    return Object.keys(map).some((key) => normalizeRampsAssetId(key) === target && map[key]);
 }
 /**
  * Filters a provider list down to those serving the given deposit asset.

package/dist/providerAvailability.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"providerAvailability.mjs","sourceRoot":"","sources":["../src/providerAvailability.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;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,OAAO,CAAC,WAAW,EAAE,CAAC;IACrC,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAC1B,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,CAClD,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 * 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, compared case-insensitively on both\n * sides. EVM CAIP-19 asset ids may arrive checksummed or lowercased and the\n * providers API returns both forms, so only the lowercased forms are compared.\n * A provider without a `supportedCryptoCurrencies` map is treated as not\n * 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 = assetId.toLowerCase();\n  return Object.keys(map).some(\n    (key) => key.toLowerCase() === 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"]}
+{"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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamask/ramps-controller",
-  "version": "19.0.0",
+  "version": "20.1.0",
   "description": "A controller for managing cryptocurrency on/off ramps functionality",
   "keywords": [
     "Ethereum",
@@ -59,8 +59,8 @@
     "@metamask/base-controller": "^9.1.0",
     "@metamask/controller-utils": "^12.3.0",
     "@metamask/messenger": "^2.0.0",
-    "@metamask/profile-sync-controller": "^28.3.0",
-    "@metamask/remote-feature-flag-controller": "^5.0.0"
+    "@metamask/profile-sync-controller": "^29.0.0",
+    "@metamask/remote-feature-flag-controller": "^6.1.0"
   },
   "devDependencies": {
     "@metamask/auto-changelog": "^6.1.0",