@metamask/ramps-controller 5.1.0 → 6.0.0

package/dist/RampsController.mjs

@@ -1,15 +1,15 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     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 __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _RampsController_instances, _RampsController_requestCacheTTL, _RampsController_requestCacheMaxSize, _RampsController_pendingRequests, _RampsController_removeRequestState, _RampsController_cleanupState, _RampsController_updateRequestState;
+var _RampsController_instances, _RampsController_requestCacheTTL, _RampsController_requestCacheMaxSize, _RampsController_pendingRequests, _RampsController_pendingResourceCount, _RampsController_clearPendingResourceCountForDependentResources, _RampsController_removeRequestState, _RampsController_cleanupState, _RampsController_fireAndForget, _RampsController_updateResourceField, _RampsController_setResourceLoading, _RampsController_setResourceError, _RampsController_updateRequestState;
 import { BaseController } from "@metamask/base-controller";
 import { DEFAULT_REQUEST_CACHE_TTL, DEFAULT_REQUEST_CACHE_MAX_SIZE, createCacheKey, isCacheExpired, createLoadingState, createSuccessState, createErrorState, RequestStatus } from "./RequestCache.mjs";
 // === GENERAL ===
@@ -19,6 +19,19 @@ import { DEFAULT_REQUEST_CACHE_TTL, DEFAULT_REQUEST_CACHE_MAX_SIZE, createCacheK
  * when composed with other controllers.
  */
 export const controllerName = 'RampsController';
+/**
+ * RampsService action types that RampsController calls via the messenger.
+ * Any host (e.g. mobile) that creates a RampsController messenger must delegate
+ * these actions from the root messenger so the controller can function.
+ */
+export const RAMPS_CONTROLLER_REQUIRED_SERVICE_ACTIONS = [
+    'RampsService:getGeolocation',
+    'RampsService:getCountries',
+    'RampsService:getTokens',
+    'RampsService:getProviders',
+    'RampsService:getPaymentMethods',
+    'RampsService:getQuotes',
+];
 /**
  * Default TTL for quotes requests (15 seconds).
  * Quotes are time-sensitive and should have a shorter cache duration.
@@ -34,12 +47,6 @@ const rampsControllerMetadata = {
         includeInStateLogs: true,
         usedInUi: true,
     },
-    selectedProvider: {
-        persist: false,
-        includeInDebugSnapshot: true,
-        includeInStateLogs: true,
-        usedInUi: true,
-    },
     countries: {
         persist: true,
         includeInDebugSnapshot: true,
@@ -58,24 +65,12 @@ const rampsControllerMetadata = {
         includeInStateLogs: true,
         usedInUi: true,
     },
-    selectedToken: {
-        persist: false,
-        includeInDebugSnapshot: true,
-        includeInStateLogs: true,
-        usedInUi: true,
-    },
     paymentMethods: {
         persist: false,
         includeInDebugSnapshot: true,
         includeInStateLogs: true,
         usedInUi: true,
     },
-    selectedPaymentMethod: {
-        persist: false,
-        includeInDebugSnapshot: true,
-        includeInStateLogs: true,
-        usedInUi: true,
-    },
     quotes: {
         persist: false,
         includeInDebugSnapshot: true,
@@ -89,6 +84,23 @@ const rampsControllerMetadata = {
         usedInUi: true,
     },
 };
+/**
+ * Creates a default resource state object.
+ *
+ * @template TData - The type of the resource data.
+ * @template TSelected - The type of the selected item.
+ * @param data - The initial data value.
+ * @param selected - The initial selected value.
+ * @returns A ResourceState object with default loading and error values.
+ */
+function createDefaultResourceState(data, selected = null) {
+    return {
+        data,
+        selected,
+        isLoading: false,
+        error: null,
+    };
+}
 /**
  * Constructs the default {@link RampsController} state. This allows
  * consumers to provide a partial state object when initializing the controller
@@ -100,17 +112,42 @@ const rampsControllerMetadata = {
 export function getDefaultRampsControllerState() {
     return {
         userRegion: null,
-        selectedProvider: null,
-        countries: [],
-        providers: [],
-        tokens: null,
-        selectedToken: null,
-        paymentMethods: [],
-        selectedPaymentMethod: null,
-        quotes: null,
+        countries: createDefaultResourceState([]),
+        providers: createDefaultResourceState([], null),
+        tokens: createDefaultResourceState(null, null),
+        paymentMethods: createDefaultResourceState([], null),
+        quotes: createDefaultResourceState(null),
         requests: {},
     };
 }
+/**
+ * Resets region-dependent resources (userRegion, providers, tokens, paymentMethods, quotes).
+ * Mutates state in place; use from within controller update() for atomic updates.
+ *
+ * @param state - The state object to mutate.
+ * @param options - Options for the reset.
+ * @param options.clearUserRegionData - When true, sets userRegion to null (e.g. for full cleanup).
+ */
+function resetDependentResources(state, options) {
+    if (options?.clearUserRegionData) {
+        state.userRegion = null;
+    }
+    state.providers.selected = null;
+    state.providers.data = [];
+    state.providers.isLoading = false;
+    state.providers.error = null;
+    state.tokens.selected = null;
+    state.tokens.data = null;
+    state.tokens.isLoading = false;
+    state.tokens.error = null;
+    state.paymentMethods.data = [];
+    state.paymentMethods.selected = null;
+    state.paymentMethods.isLoading = false;
+    state.paymentMethods.error = null;
+    state.quotes.data = null;
+    state.quotes.isLoading = false;
+    state.quotes.error = null;
+}
 // === HELPER FUNCTIONS ===
 /**
  * Finds a country and state from a region code string.
@@ -169,6 +206,15 @@ function findRegionFromCode(regionCode, countries) {
  * Manages cryptocurrency on/off ramps functionality.
  */
 export class RampsController extends BaseController {
+    /**
+     * Clears the pending resource count map. Used only in tests to exercise the
+     * defensive path when get() returns undefined in the finally block.
+     *
+     * @internal
+     */
+    clearPendingResourceCountForTest() {
+        __classPrivateFieldGet(this, _RampsController_pendingResourceCount, "f").clear();
+    }
     /**
      * Constructs a new {@link RampsController}.
      *
@@ -205,6 +251,11 @@ export class RampsController extends BaseController {
          * Key is the cache key, value is the pending request with abort controller.
          */
         _RampsController_pendingRequests.set(this, new Map());
+        /**
+         * Count of in-flight requests per resource type.
+         * Used so isLoading is only cleared when the last request for that resource finishes.
+         */
+        _RampsController_pendingResourceCount.set(this, new Map());
         __classPrivateFieldSet(this, _RampsController_requestCacheTTL, requestCacheTTL, "f");
         __classPrivateFieldSet(this, _RampsController_requestCacheMaxSize, requestCacheMaxSize, "f");
     }
@@ -236,8 +287,18 @@ export class RampsController extends BaseController {
         // Create abort controller for this request
         const abortController = new AbortController();
         const lastFetchedAt = Date.now();
+        const { resourceType } = options ?? {};
         // Update state to loading
         __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_updateRequestState).call(this, cacheKey, createLoadingState());
+        // Set resource-level loading state (only on cache miss). Ref-count so concurrent
+        // requests for the same resource type (different cache keys) keep isLoading true.
+        if (resourceType) {
+            const count = __classPrivateFieldGet(this, _RampsController_pendingResourceCount, "f").get(resourceType) ?? 0;
+            __classPrivateFieldGet(this, _RampsController_pendingResourceCount, "f").set(resourceType, count + 1);
+            if (count === 0) {
+                __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_setResourceLoading).call(this, resourceType, true);
+            }
+        }
         // Create the fetch promise
         const promise = (async () => {
             try {
@@ -247,6 +308,15 @@ export class RampsController extends BaseController {
                     throw new Error('Request was aborted');
                 }
                 __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_updateRequestState).call(this, cacheKey, createSuccessState(data, lastFetchedAt));
+                if (resourceType) {
+                    // We need the extra logic because there are two situations where we’re allowed to clear the error:
+                    // No callback → always clear
+                    // Callback present → clear only when isResultCurrent() returns true.
+                    const isCurrent = !options?.isResultCurrent || options.isResultCurrent();
+                    if (isCurrent) {
+                        __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_setResourceError).call(this, resourceType, null);
+                    }
+                }
                 return data;
             }
             catch (error) {
@@ -254,8 +324,14 @@ export class RampsController extends BaseController {
                 if (abortController.signal.aborted) {
                     throw error;
                 }
-                const errorMessage = error?.message;
-                __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_updateRequestState).call(this, cacheKey, createErrorState(errorMessage ?? 'Unknown error', lastFetchedAt));
+                const errorMessage = error?.message ?? 'Unknown error';
+                __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_updateRequestState).call(this, cacheKey, createErrorState(errorMessage, lastFetchedAt));
+                if (resourceType) {
+                    const isCurrent = !options?.isResultCurrent || options.isResultCurrent();
+                    if (isCurrent) {
+                        __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_setResourceError).call(this, resourceType, errorMessage);
+                    }
+                }
                 throw error;
             }
             finally {
@@ -264,6 +340,18 @@ export class RampsController extends BaseController {
                 if (currentPending?.abortController === abortController) {
                     __classPrivateFieldGet(this, _RampsController_pendingRequests, "f").delete(cacheKey);
                 }
+                // Clear resource-level loading state only when no requests for this resource remain
+                if (resourceType) {
+                    const count = __classPrivateFieldGet(this, _RampsController_pendingResourceCount, "f").get(resourceType) ?? 0;
+                    const next = Math.max(0, count - 1);
+                    if (next === 0) {
+                        __classPrivateFieldGet(this, _RampsController_pendingResourceCount, "f").delete(resourceType);
+                        __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_setResourceLoading).call(this, resourceType, false);
+                    }
+                    else {
+                        __classPrivateFieldGet(this, _RampsController_pendingResourceCount, "f").set(resourceType, next);
+                    }
+                }
             }
         })();
         // Store pending request for deduplication
@@ -306,37 +394,40 @@ export class RampsController extends BaseController {
     async setUserRegion(region, options) {
         const normalizedRegion = region.toLowerCase().trim();
         try {
-            const { countries } = this.state;
-            if (!countries || countries.length === 0) {
+            const countriesData = this.state.countries.data;
+            if (!countriesData || countriesData.length === 0) {
                 __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_cleanupState).call(this);
                 throw new Error('No countries found. Cannot set user region without valid country information.');
             }
-            const userRegion = findRegionFromCode(normalizedRegion, countries);
+            const userRegion = findRegionFromCode(normalizedRegion, countriesData);
             if (!userRegion) {
                 __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_cleanupState).call(this);
                 throw new Error(`Region "${normalizedRegion}" not found in countries data. Cannot set user region without valid country information.`);
             }
-            // Only cleanup state if region is actually changing
             const regionChanged = normalizedRegion !== this.state.userRegion?.regionCode;
-            // Set the new region atomically with cleanup to avoid intermediate null state
+            const needsRefetch = regionChanged ||
+                !this.state.tokens.data ||
+                this.state.providers.data.length === 0;
+            if (regionChanged) {
+                __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_clearPendingResourceCountForDependentResources).call(this);
+            }
             this.update((state) => {
                 if (regionChanged) {
-                    state.selectedProvider = null;
-                    state.selectedToken = null;
-                    state.tokens = null;
-                    state.providers = [];
-                    state.paymentMethods = [];
-                    state.selectedPaymentMethod = null;
-                    state.quotes = null;
+                    resetDependentResources(state);
                 }
                 state.userRegion = userRegion;
             });
-            // Only trigger fetches if region changed or if data is missing
-            if (regionChanged || !this.state.tokens) {
-                this.triggerGetTokens(userRegion.regionCode, 'buy', options);
-            }
-            if (regionChanged || this.state.providers.length === 0) {
-                this.triggerGetProviders(userRegion.regionCode, options);
+            if (needsRefetch) {
+                const refetchPromises = [];
+                if (regionChanged || !this.state.tokens.data) {
+                    refetchPromises.push(this.getTokens(userRegion.regionCode, 'buy', options));
+                }
+                if (regionChanged || this.state.providers.data.length === 0) {
+                    refetchPromises.push(this.getProviders(userRegion.regionCode, options));
+                }
+                if (refetchPromises.length > 0) {
+                    __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_fireAndForget).call(this, Promise.all(refetchPromises));
+                }
             }
             return userRegion;
         }
@@ -356,9 +447,9 @@ export class RampsController extends BaseController {
     setSelectedProvider(providerId) {
         if (providerId === null) {
             this.update((state) => {
-                state.selectedProvider = null;
-                state.paymentMethods = [];
-                state.selectedPaymentMethod = null;
+                state.providers.selected = null;
+                state.paymentMethods.data = [];
+                state.paymentMethods.selected = null;
             });
             return;
         }
@@ -366,7 +457,7 @@ export class RampsController extends BaseController {
         if (!regionCode) {
             throw new Error('Region is required. Cannot set selected provider without valid region information.');
         }
-        const { providers } = this.state;
+        const providers = this.state.providers.data;
         if (!providers || providers.length === 0) {
             throw new Error('Providers not loaded. Cannot set selected provider before providers are fetched.');
         }
@@ -375,16 +466,11 @@ export class RampsController extends BaseController {
             throw new Error(`Provider with ID "${providerId}" not found in available providers.`);
         }
         this.update((state) => {
-            state.selectedProvider = provider;
-            state.paymentMethods = [];
-            state.selectedPaymentMethod = null;
-        });
-        // fetch payment methods for the new provider
-        // this is needed because you can change providers without changing the token
-        // (getPaymentMethods will use state as its default)
-        this.triggerGetPaymentMethods(regionCode, {
-            provider: provider.id,
+            state.providers.selected = provider;
+            state.paymentMethods.data = [];
+            state.paymentMethods.selected = null;
         });
+        __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_fireAndForget).call(this, this.getPaymentMethods(regionCode, { provider: provider.id }));
     }
     /**
      * Initializes the controller by fetching the user's region from geolocation.
@@ -410,8 +496,8 @@ export class RampsController extends BaseController {
         if (!regionCode) {
             throw new Error('Region code is required. Cannot hydrate state without valid region information.');
         }
-        this.triggerGetTokens(regionCode, 'buy', options);
-        this.triggerGetProviders(regionCode, options);
+        __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_fireAndForget).call(this, this.getTokens(regionCode, 'buy', options));
+        __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_fireAndForget).call(this, this.getProviders(regionCode, options));
     }
     /**
      * Fetches the list of supported countries.
@@ -425,9 +511,9 @@ export class RampsController extends BaseController {
         const cacheKey = createCacheKey('getCountries', []);
         const countries = await this.executeRequest(cacheKey, async () => {
             return this.messenger.call('RampsService:getCountries');
-        }, options);
+        }, { ...options, resourceType: 'countries' });
         this.update((state) => {
-            state.countries = countries;
+            state.countries.data = countries;
         });
         return countries;
     }
@@ -456,11 +542,16 @@ export class RampsController extends BaseController {
             return this.messenger.call('RampsService:getTokens', normalizedRegion, action, {
                 provider: options?.provider,
             });
-        }, options);
+        }, {
+            ...options,
+            resourceType: 'tokens',
+            isResultCurrent: () => this.state.userRegion?.regionCode === undefined ||
+                this.state.userRegion?.regionCode === normalizedRegion,
+        });
         this.update((state) => {
             const userRegionCode = state.userRegion?.regionCode;
             if (userRegionCode === undefined || userRegionCode === normalizedRegion) {
-                state.tokens = tokens;
+                state.tokens.data = tokens;
             }
         });
         return tokens;
@@ -476,9 +567,9 @@ export class RampsController extends BaseController {
     setSelectedToken(assetId) {
         if (!assetId) {
             this.update((state) => {
-                state.selectedToken = null;
-                state.paymentMethods = [];
-                state.selectedPaymentMethod = null;
+                state.tokens.selected = null;
+                state.paymentMethods.data = [];
+                state.paymentMethods.selected = null;
             });
             return;
         }
@@ -486,7 +577,7 @@ export class RampsController extends BaseController {
         if (!regionCode) {
             throw new Error('Region is required. Cannot set selected token without valid region information.');
         }
-        const { tokens } = this.state;
+        const tokens = this.state.tokens.data;
         if (!tokens) {
             throw new Error('Tokens not loaded. Cannot set selected token before tokens are fetched.');
         }
@@ -496,13 +587,11 @@ export class RampsController extends BaseController {
             throw new Error(`Token with asset ID "${assetId}" not found in available tokens.`);
         }
         this.update((state) => {
-            state.selectedToken = token;
-            state.paymentMethods = [];
-            state.selectedPaymentMethod = null;
-        });
-        this.triggerGetPaymentMethods(regionCode, {
-            assetId: token.assetId,
+            state.tokens.selected = token;
+            state.paymentMethods.data = [];
+            state.paymentMethods.selected = null;
         });
+        __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_fireAndForget).call(this, this.getPaymentMethods(regionCode, { assetId: token.assetId }));
     }
     /**
      * Fetches the list of providers for a given region.
@@ -536,11 +625,16 @@ export class RampsController extends BaseController {
                 fiat: options?.fiat,
                 payments: options?.payments,
             });
-        }, options);
+        }, {
+            ...options,
+            resourceType: 'providers',
+            isResultCurrent: () => this.state.userRegion?.regionCode === undefined ||
+                this.state.userRegion?.regionCode === normalizedRegion,
+        });
         this.update((state) => {
             const userRegionCode = state.userRegion?.regionCode;
             if (userRegionCode === undefined || userRegionCode === normalizedRegion) {
-                state.providers = providers;
+                state.providers.data = providers;
             }
         });
         return { providers };
@@ -559,8 +653,8 @@ export class RampsController extends BaseController {
     async getPaymentMethods(region, options) {
         const regionCode = region ?? this.state.userRegion?.regionCode ?? null;
         const fiatToUse = options?.fiat ?? this.state.userRegion?.country?.currency ?? null;
-        const assetIdToUse = options?.assetId ?? this.state.selectedToken?.assetId ?? '';
-        const providerToUse = options?.provider ?? this.state.selectedProvider?.id ?? '';
+        const assetIdToUse = options?.assetId ?? this.state.tokens.selected?.assetId ?? '';
+        const providerToUse = options?.provider ?? this.state.providers.selected?.id ?? '';
         if (!regionCode) {
             throw new Error('Region is required. Either provide a region parameter or ensure userRegion is set in controller state.');
         }
@@ -582,21 +676,31 @@ export class RampsController extends BaseController {
                 assetId: assetIdToUse,
                 provider: providerToUse,
             });
-        }, options);
+        }, {
+            ...options,
+            resourceType: 'paymentMethods',
+            isResultCurrent: () => {
+                const regionMatch = this.state.userRegion?.regionCode === undefined ||
+                    this.state.userRegion?.regionCode === normalizedRegion;
+                const tokenMatch = (this.state.tokens.selected?.assetId ?? '') === assetIdToUse;
+                const providerMatch = (this.state.providers.selected?.id ?? '') === providerToUse;
+                return regionMatch && tokenMatch && providerMatch;
+            },
+        });
         this.update((state) => {
-            const currentAssetId = state.selectedToken?.assetId ?? '';
-            const currentProviderId = state.selectedProvider?.id ?? '';
+            const currentAssetId = state.tokens.selected?.assetId ?? '';
+            const currentProviderId = state.providers.selected?.id ?? '';
             const tokenSelectionUnchanged = assetIdToUse === currentAssetId;
             const providerSelectionUnchanged = providerToUse === currentProviderId;
             // this is a race condition check to ensure that the selected token and provider in state are the same as the tokens we're requesting for
             // ex: if the user rapidly changes the token or provider, the in-flight payment methods might not be valid
             // so this check will ensure that the payment methods are still valid for the token and provider that were requested
             if (tokenSelectionUnchanged && providerSelectionUnchanged) {
-                state.paymentMethods = response.payments;
+                state.paymentMethods.data = response.payments;
                 // this will auto-select the first payment method if the selected payment method is not in the new payment methods
-                const currentSelectionStillValid = response.payments.some((pm) => pm.id === state.selectedPaymentMethod?.id);
+                const currentSelectionStillValid = response.payments.some((pm) => pm.id === state.paymentMethods.selected?.id);
                 if (!currentSelectionStillValid) {
-                    state.selectedPaymentMethod = response.payments[0] ?? null;
+                    state.paymentMethods.selected = response.payments[0] ?? null;
                 }
             }
         });
@@ -612,11 +716,11 @@ export class RampsController extends BaseController {
     setSelectedPaymentMethod(paymentMethodId) {
         if (!paymentMethodId) {
             this.update((state) => {
-                state.selectedPaymentMethod = null;
+                state.paymentMethods.selected = null;
             });
             return;
         }
-        const { paymentMethods } = this.state;
+        const paymentMethods = this.state.paymentMethods.data;
         if (!paymentMethods || paymentMethods.length === 0) {
             throw new Error('Payment methods not loaded. Cannot set selected payment method before payment methods are fetched.');
         }
@@ -625,7 +729,7 @@ export class RampsController extends BaseController {
             throw new Error(`Payment method with ID "${paymentMethodId}" not found in available payment methods.`);
         }
         this.update((state) => {
-            state.selectedPaymentMethod = paymentMethod;
+            state.paymentMethods.selected = paymentMethod;
         });
     }
     /**
@@ -650,7 +754,7 @@ export class RampsController extends BaseController {
         const regionToUse = options.region ?? this.state.userRegion?.regionCode;
         const fiatToUse = options.fiat ?? this.state.userRegion?.country?.currency;
         const paymentMethodsToUse = options.paymentMethods ??
-            this.state.paymentMethods.map((pm) => pm.id);
+            this.state.paymentMethods.data.map((pm) => pm.id);
         const action = options.action ?? 'buy';
         if (!regionToUse) {
             throw new Error('Region is required. Either provide a region parameter or ensure userRegion is set in controller state.');
@@ -701,11 +805,14 @@ export class RampsController extends BaseController {
         }, {
             forceRefresh: options.forceRefresh,
             ttl: options.ttl ?? DEFAULT_QUOTES_TTL,
+            resourceType: 'quotes',
+            isResultCurrent: () => this.state.userRegion?.regionCode === undefined ||
+                this.state.userRegion?.regionCode === normalizedRegion,
         });
         this.update((state) => {
             const userRegionCode = state.userRegion?.regionCode;
             if (userRegionCode === undefined || userRegionCode === normalizedRegion) {
-                state.quotes = response;
+                state.quotes.data = response;
             }
         });
         return response;
@@ -720,107 +827,40 @@ export class RampsController extends BaseController {
     getWidgetUrl(quote) {
         return quote.quote?.widgetUrl ?? null;
     }
-    // ============================================================
-    // Sync Trigger Methods
-    // These fire-and-forget methods are for use in React effects.
-    // Errors are stored in state and available via selectors.
-    // ============================================================
-    /**
-     * Triggers setting the user region without throwing.
-     *
-     * @param region - The region code to set (e.g., "US-CA").
-     * @param options - Options for cache behavior.
-     */
-    triggerSetUserRegion(region, options) {
-        this.setUserRegion(region, options).catch(() => {
-            // Error stored in state
-        });
-    }
-    /**
-     * Triggers fetching countries without throwing.
-     *
-     * @param options - Options for cache behavior.
-     */
-    triggerGetCountries(options) {
-        this.getCountries(options).catch(() => {
-            // Error stored in state
-        });
-    }
-    /**
-     * Triggers fetching tokens without throwing.
-     *
-     * @param region - The region code. If not provided, uses userRegion from state.
-     * @param action - The ramp action type ('buy' or 'sell').
-     * @param options - Options for cache behavior.
-     */
-    triggerGetTokens(region, action = 'buy', options) {
-        this.getTokens(region, action, options).catch(() => {
-            // Error stored in state
-        });
-    }
-    /**
-     * Triggers fetching providers without throwing.
-     *
-     * @param region - The region code. If not provided, uses userRegion from state.
-     * @param options - Options for cache behavior and query filters.
-     */
-    triggerGetProviders(region, options) {
-        this.getProviders(region, options).catch(() => {
-            // Error stored in state
-        });
-    }
-    /**
-     * Triggers fetching payment methods without throwing.
-     *
-     * @param region - User's region code (e.g., "us", "fr", "us-ny").
-     * @param options - Query parameters for filtering payment methods.
-     * @param options.fiat - Fiat currency code. If not provided, uses userRegion currency.
-     * @param options.assetId - CAIP-19 cryptocurrency identifier.
-     * @param options.provider - Provider ID path.
-     */
-    triggerGetPaymentMethods(region, options) {
-        this.getPaymentMethods(region, options).catch(() => {
-            // Error stored in state
-        });
-    }
-    /**
-     * Triggers fetching quotes without throwing.
-     *
-     * @param options - The parameters for fetching quotes.
-     * @param options.region - User's region code. If not provided, uses userRegion from state.
-     * @param options.fiat - Fiat currency code. If not provided, uses userRegion currency.
-     * @param options.assetId - CAIP-19 cryptocurrency identifier.
-     * @param options.amount - The amount (in fiat for buy, crypto for sell).
-     * @param options.walletAddress - The destination wallet address.
-     * @param options.paymentMethods - Array of payment method IDs. If not provided, uses paymentMethods from state.
-     * @param options.provider - Optional provider ID to filter quotes.
-     * @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.
-     * @param options.ttl - Custom TTL for this request.
-     */
-    triggerGetQuotes(options) {
-        this.getQuotes(options).catch(() => {
-            // Error stored in state
-        });
-    }
 }
-_RampsController_requestCacheTTL = new WeakMap(), _RampsController_requestCacheMaxSize = new WeakMap(), _RampsController_pendingRequests = new WeakMap(), _RampsController_instances = new WeakSet(), _RampsController_removeRequestState = function _RampsController_removeRequestState(cacheKey) {
+_RampsController_requestCacheTTL = new WeakMap(), _RampsController_requestCacheMaxSize = new WeakMap(), _RampsController_pendingRequests = new WeakMap(), _RampsController_pendingResourceCount = new WeakMap(), _RampsController_instances = new WeakSet(), _RampsController_clearPendingResourceCountForDependentResources = function _RampsController_clearPendingResourceCountForDependentResources() {
+    const types = [
+        'providers',
+        'tokens',
+        'paymentMethods',
+        'quotes',
+    ];
+    for (const resourceType of types) {
+        __classPrivateFieldGet(this, _RampsController_pendingResourceCount, "f").delete(resourceType);
+    }
+}, _RampsController_removeRequestState = function _RampsController_removeRequestState(cacheKey) {
     this.update((state) => {
         const requests = state.requests;
         delete requests[cacheKey];
     });
 }, _RampsController_cleanupState = function _RampsController_cleanupState() {
+    __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_clearPendingResourceCountForDependentResources).call(this);
+    this.update((state) => resetDependentResources(state, {
+        clearUserRegionData: true,
+    }));
+}, _RampsController_fireAndForget = function _RampsController_fireAndForget(promise) {
+    promise.catch((_error) => undefined);
+}, _RampsController_updateResourceField = function _RampsController_updateResourceField(resourceType, field, value) {
     this.update((state) => {
-        state.userRegion = null;
-        state.selectedProvider = null;
-        state.selectedToken = null;
-        state.tokens = null;
-        state.providers = [];
-        state.paymentMethods = [];
-        state.selectedPaymentMethod = null;
-        state.quotes = null;
+        const resource = state[resourceType];
+        if (resource) {
+            resource[field] = value;
+        }
     });
+}, _RampsController_setResourceLoading = function _RampsController_setResourceLoading(resourceType, loading) {
+    __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_updateResourceField).call(this, resourceType, 'isLoading', loading);
+}, _RampsController_setResourceError = function _RampsController_setResourceError(resourceType, error) {
+    __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_updateResourceField).call(this, resourceType, 'error', error);
 }, _RampsController_updateRequestState = function _RampsController_updateRequestState(cacheKey, requestState) {
     const maxSize = __classPrivateFieldGet(this, _RampsController_requestCacheMaxSize, "f");
     const ttl = __classPrivateFieldGet(this, _RampsController_requestCacheTTL, "f");