@metamask-previews/ramps-controller 14.0.0-preview-e15374a5d → 14.1.0-preview-d3cc77e

package/dist/RampsController.cjs

@@ -10,7 +10,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _RampsController_instances, _RampsController_requestCacheTTL, _RampsController_requestCacheMaxSize, _RampsController_pendingRequests, _RampsController_pendingResourceCount, _RampsController_pendingResourceGeneration, _RampsController_orderPollingMeta, _RampsController_orderPollingTimer, _RampsController_isPolling, _RampsController_initPromise, _RampsController_clearPendingResourceCountForDependentResources, _RampsController_abortDependentRequests, _RampsController_mutateRequests, _RampsController_removeRequestState, _RampsController_cleanupState, _RampsController_requireRegion, _RampsController_isRegionCurrent, _RampsController_isTokenCurrent, _RampsController_isProviderCurrent, _RampsController_updateResourceField, _RampsController_setResourceLoading, _RampsController_setResourceError, _RampsController_updateRequestState, _RampsController_runInit, _RampsController_refreshOrder, _RampsController_pollPendingOrders, _RampsController_syncTransakAuthOnError, _RampsController_getNormalizedTransakError;
+var _RampsController_instances, _RampsController_requestCacheTTL, _RampsController_requestCacheMaxSize, _RampsController_pendingRequests, _RampsController_pendingResourceCount, _RampsController_pendingResourceGeneration, _RampsController_orderPollingMeta, _RampsController_orderPollingTimer, _RampsController_isPolling, _RampsController_initPromise, _RampsController_clearPendingResourceCountForDependentResources, _RampsController_abortDependentRequests, _RampsController_mutateRequests, _RampsController_removeRequestState, _RampsController_cleanupState, _RampsController_requireRegion, _RampsController_isRegionCurrent, _RampsController_isTokenCurrent, _RampsController_isProviderCurrent, _RampsController_updateResourceField, _RampsController_setResourceLoading, _RampsController_setResourceError, _RampsController_updateRequestState, _RampsController_runInit, _RampsController_getSupportingProvidersForRegion, _RampsController_filterProviderIdsBySupport, _RampsController_resolveProviderIdsForQuote, _RampsController_getPreferredProviderIdsFromOrders, _RampsController_refreshOrder, _RampsController_pollPendingOrders, _RampsController_syncTransakAuthOnError, _RampsController_getNormalizedTransakError;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RampsController = exports.normalizeProviderCode = exports.getDefaultRampsControllerState = exports.RAMPS_CONTROLLER_REQUIRED_SERVICE_ACTIONS = exports.controllerName = void 0;
 const base_controller_1 = require("@metamask/base-controller");
@@ -953,6 +953,18 @@ class RampsController extends base_controller_1.BaseController {
      * @param options.walletAddress - The destination wallet address.
      * @param options.paymentMethods - Array of payment method IDs. If not provided, uses paymentMethods from state.
      * @param options.providers - Optional provider IDs to filter quotes.
+     * @param options.autoSelectProvider - When true and `providers` is omitted,
+     *   resolves a provider that supports `assetId` for this request only (no
+     *   state mutation). Ignored when `providers` is passed.
+     * @param options.preferredProviderIds - Optional provider IDs to prefer
+     *   during auto-selection, in priority order (e.g. derived by the caller
+     *   from completed-order history). Only used when `autoSelectProvider` is
+     *   true and `providers` is omitted.
+     * @param options.restrictToKnownOrNativeProviders - Headless-buy v0 gating. When
+     *   true, auto-selection resolves only a native provider, and an explicitly
+     *   passed `providers` list is filtered to those supporting the region and
+     *   asset. If nothing qualifies, `getQuotes` returns an empty response
+     *   instead of quoting other providers.
      * @param options.redirectUrl - Optional redirect URL after order completion.
      * @param options.action - The ramp action type. Defaults to 'buy'.
      * @param options.forceRefresh - Whether to bypass cache.
@@ -964,8 +976,6 @@ class RampsController extends base_controller_1.BaseController {
         const fiatToUse = options.fiat ?? this.state.userRegion?.country?.currency;
         const paymentMethodsToUse = options.paymentMethods ??
             this.state.paymentMethods.data.map((pm) => pm.id);
-        const providersToUse = options.providers ??
-            this.state.providers.data.map((provider) => provider.id);
         const action = options.action ?? 'buy';
         const assetIdToUse = options.assetId ?? this.state.tokens.selected?.assetId;
         if (!fiatToUse) {
@@ -975,6 +985,31 @@ class RampsController extends base_controller_1.BaseController {
         if (normalizedAssetIdForValidation === '') {
             throw new Error('assetId is required.');
         }
+        let providersToUse;
+        if (options.providers) {
+            providersToUse = options.restrictToKnownOrNativeProviders
+                ? await __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_filterProviderIdsBySupport).call(this, {
+                    providerIds: options.providers,
+                    assetId: normalizedAssetIdForValidation,
+                    region: regionToUse,
+                })
+                : options.providers;
+        }
+        else if (options.autoSelectProvider ||
+            options.restrictToKnownOrNativeProviders) {
+            // The restriction flag implies resolution: it must narrow the provider
+            // set even when `autoSelectProvider` was not explicitly passed, otherwise
+            // it would be silently ignored and every provider quoted.
+            providersToUse = await __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_resolveProviderIdsForQuote).call(this, {
+                assetId: normalizedAssetIdForValidation,
+                region: regionToUse,
+                preferredProviderIds: options.preferredProviderIds,
+                restrictToKnownOrNative: options.restrictToKnownOrNativeProviders,
+            });
+        }
+        else {
+            providersToUse = this.state.providers.data.map((provider) => provider.id);
+        }
         if (!paymentMethodsToUse ||
             paymentMethodsToUse.length === 0 ||
             paymentMethodsToUse.some((pm) => pm.trim() === '')) {
@@ -986,6 +1021,14 @@ class RampsController extends base_controller_1.BaseController {
         if (!options.walletAddress || options.walletAddress.trim() === '') {
             throw new Error('walletAddress is required.');
         }
+        // Under headless-buy gating, an empty resolved provider list means no
+        // eligible (native/supporting) provider exists. Return an empty response
+        // rather than passing `[]` to the service, which omits the provider filter
+        // and would quote every provider.
+        if (options.restrictToKnownOrNativeProviders &&
+            providersToUse.length === 0) {
+            return { success: [], sorted: [], error: [], customActions: [] };
+        }
         const normalizedRegion = regionToUse.toLowerCase().trim();
         const normalizedFiat = fiatToUse.toLowerCase().trim();
         const normalizedAssetId = normalizedAssetIdForValidation;
@@ -1727,6 +1770,142 @@ _RampsController_requestCacheTTL = new WeakMap(), _RampsController_requestCacheM
         throw new Error('Failed to fetch geolocation. Cannot initialize controller without valid region information.');
     }
     await this.setUserRegion(regionCode, options);
+}, _RampsController_getSupportingProvidersForRegion = 
+/**
+ * Returns the region's providers that support the given asset, plus the full
+ * region provider list. Uses cached providers only when the request targets
+ * the current region; otherwise fetches for the requested region, since
+ * `getProviders` does not persist results for a non-current region. Does not
+ * mutate state.
+ *
+ * @param options - The options.
+ * @param options.assetId - CAIP-19 asset type identifier to resolve for.
+ * @param options.region - Region to resolve providers for.
+ * @returns The supporting providers and the full region provider list.
+ */
+async function _RampsController_getSupportingProvidersForRegion({ assetId, region, }) {
+    const normalizedRegion = region.toLowerCase().trim();
+    let providers;
+    if (__classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_isRegionCurrent).call(this, normalizedRegion) &&
+        this.state.providers.data.length > 0) {
+        providers = this.state.providers.data;
+    }
+    else {
+        ({ providers } = await this.getProviders(normalizedRegion));
+    }
+    // EVM CAIP-19 asset IDs may arrive checksummed or lowercased, and the
+    // providers API returns both forms, so match case-insensitively on both
+    // sides. Only the lowercased forms are compared (the original IDs are never
+    // returned), so case-sensitive non-EVM asset IDs are not corrupted.
+    const normalizedAssetId = assetId.toLowerCase();
+    const supporting = providers.filter((provider) => {
+        const map = provider?.supportedCryptoCurrencies;
+        if (!map) {
+            return false;
+        }
+        return Object.keys(map).some((key) => key.toLowerCase() === normalizedAssetId);
+    });
+    return { supporting, all: providers };
+}, _RampsController_filterProviderIdsBySupport = 
+/**
+ * Filters an explicitly-requested provider ID list down to those that support
+ * the asset in the region. Used for headless-buy gating so an explicitly
+ * passed provider that cannot serve the region/asset yields no providers
+ * rather than being trusted blindly.
+ *
+ * @param options - The options.
+ * @param options.providerIds - Explicitly requested provider IDs.
+ * @param options.assetId - CAIP-19 asset type identifier to resolve for.
+ * @param options.region - Region to resolve providers for.
+ * @returns The subset of `providerIds` supporting the asset in the region.
+ */
+async function _RampsController_filterProviderIdsBySupport({ providerIds, assetId, region, }) {
+    const { supporting } = await __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getSupportingProvidersForRegion).call(this, {
+        assetId,
+        region,
+    });
+    const supportingIds = new Set(supporting.map((provider) => provider.id));
+    return providerIds.filter((id) => supportingIds.has(id));
+}, _RampsController_resolveProviderIdsForQuote = 
+/**
+ * Resolves the provider IDs to use for a single quote request, scoped to the
+ * given asset and region. Does not mutate `providers.selected` or any other
+ * state.
+ *
+ * Resolves against the region's supporting providers using this precedence:
+ * 1. The currently selected provider, if it is in the supporting set.
+ * 2. The first preferred provider that supports the asset, where the
+ *    preference is taken from `preferredProviderIds` when supplied, otherwise
+ *    derived from the user's completed-order history (most recent first).
+ *    This takes priority over Transak Native to preserve an existing KYC
+ *    relationship.
+ * 3. A native provider (e.g. Transak Native).
+ * 4. The first supporting provider — unless `restrictToKnownOrNative` is set, in
+ *    which case no further provider is introduced and nothing is returned.
+ *
+ * When `restrictToKnownOrNative` is unset and no provider supports the asset, falls
+ * back to all known provider IDs so the request behaves as if no
+ * auto-selection occurred.
+ *
+ * @param options - The options.
+ * @param options.assetId - CAIP-19 asset type identifier to resolve for.
+ * @param options.region - Region to resolve providers for.
+ * @param options.preferredProviderIds - Provider IDs to prefer, in order.
+ * @param options.restrictToKnownOrNative - When true, resolve only a native provider
+ *   (or no providers when none supports the asset).
+ * @returns Provider IDs for this request only.
+ */
+async function _RampsController_resolveProviderIdsForQuote({ assetId, region, preferredProviderIds, restrictToKnownOrNative, }) {
+    const { supporting, all } = await __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getSupportingProvidersForRegion).call(this, {
+        assetId,
+        region,
+    });
+    // When not restricted and nothing supports the asset, behave as if no
+    // auto-selection occurred (quote against all known providers).
+    if (!restrictToKnownOrNative && supporting.length === 0) {
+        return all.map((provider) => provider.id);
+    }
+    // 1. The currently selected provider, if it supports the asset.
+    const { selected } = this.state.providers;
+    if (selected &&
+        supporting.some((provider) => provider.id === selected.id)) {
+        return [selected.id];
+    }
+    // 2. A provider the user has transacted with before — from
+    //    `preferredProviderIds` when supplied, otherwise completed-order
+    //    history. Takes priority over Transak Native to preserve an existing
+    //    KYC relationship and avoid churn.
+    const preferred = preferredProviderIds ?? __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getPreferredProviderIdsFromOrders).call(this);
+    for (const preferredId of preferred) {
+        const match = supporting.find((provider) => provider.id === preferredId);
+        if (match) {
+            return [match.id];
+        }
+    }
+    // 3. A native provider (e.g. Transak Native).
+    const nativeProvider = supporting.find((provider) => provider.type === 'native');
+    if (nativeProvider) {
+        return [nativeProvider.id];
+    }
+    // 4. Fallback. Under headless gating, introduce no other provider — return
+    //    nothing so the caller surfaces an "unavailable" state. Otherwise the
+    //    aggregator and all other providers are treated equally: first wins.
+    if (restrictToKnownOrNative) {
+        return [];
+    }
+    return [supporting[0].id];
+}, _RampsController_getPreferredProviderIdsFromOrders = function _RampsController_getPreferredProviderIdsFromOrders() {
+    const orderedIds = [];
+    const completedOrders = this.state.orders
+        .filter((order) => order.status === RampsService_1.RampsOrderStatus.Completed && order.provider?.id)
+        .sort((orderA, orderB) => orderB.createdAt - orderA.createdAt);
+    for (const order of completedOrders) {
+        const id = order.provider?.id;
+        if (id && !orderedIds.includes(id)) {
+            orderedIds.push(id);
+        }
+    }
+    return orderedIds;
 }, _RampsController_refreshOrder = 
 /**
  * Refreshes a single order via the V2 API and updates it in state.