@metamask/ramps-controller 20.3.0 → 22.0.0

package/dist/{RampsController.mjs → RampsController.js}

@@ -1,28 +1,17 @@
-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 _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_resolveAllProvidersFlag, _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_syncUserRegionFromCountriesCatalog, _RampsController_pickWidenedQuote, _RampsController_getSupportingProvidersForRegion, _RampsController_filterProviderIdsBySupport, _RampsController_resolveProviderIdsForQuote, _RampsController_resolveProviderIdsForPaymentMethods, _RampsController_getPreferredProviderIdsFromOrders, _RampsController_applyAutorampRemoteSnapshot, _RampsController_refreshOrder, _RampsController_pollPendingOrders, _RampsController_syncTransakAuthOnError, _RampsController_getNormalizedTransakError;
-import { BaseController } from "@metamask/base-controller";
-import { BrokenCircuitError } from "@metamask/controller-utils";
-import { applyAutorampRemoteStatus, createAutorampAccount, markAutorampNotified } from "./autorampAccount.mjs";
-import { getHeadlessProviderAllowlist, isHeadlessAllProvidersEnabled, normalizeHeadlessProviderId } from "./featureFlags.mjs";
-import { PENDING_ORDER_STATUSES, TERMINAL_ORDER_STATUSES } from "./orderStatus.mjs";
-import { buildOwnershipMessage } from "./ownership-message.mjs";
-import { mergePaymentMethodsById, pickPaymentMethod } from "./paymentMethodMerge.mjs";
-import { getProvidersServingAsset, normalizeRampsAssetId, providerServesAsset } from "./providerAvailability.mjs";
-import { RAMPS_ERROR_CODES } from "./rampsErrorCodes.mjs";
-import { RampsOrderStatus } from "./RampsService.mjs";
-import { DEFAULT_REQUEST_CACHE_TTL, DEFAULT_REQUEST_CACHE_MAX_SIZE, createCacheKey, isCacheExpired, createLoadingState, createSuccessState, createErrorState, RequestStatus } from "./RequestCache.mjs";
-import { createInitialState as createInitialWalletRegistrationState, transition as transitionWalletRegistration } from "./wallet-registration-machine.mjs";
-import { createIdempotencyKey, WalletRegistrationError } from "./wallet-registration-service.mjs";
+import { BaseController } from '@metamask/base-controller';
+import { BrokenCircuitError } from '@metamask/controller-utils';
+import { applyAutorampRemoteStatus, createAutorampAccount, markAutorampNotified, } from './autorampAccount.js';
+import { getHeadlessProviderAllowlist, isHeadlessAllProvidersEnabled, normalizeHeadlessProviderId, } from './featureFlags.js';
+import { areOrdersEqual, deleteOrderInUserStorage, syncOrdersWithUserStorage as syncOrdersWithUserStorageInternal, updateOrderInUserStorage, } from './order-syncing/index.js';
+import { PENDING_ORDER_STATUSES, TERMINAL_ORDER_STATUSES, } from './orderStatus.js';
+import { buildOwnershipMessage } from './ownership-message.js';
+import { mergePaymentMethodsById, pickPaymentMethod, } from './paymentMethodMerge.js';
+import { getProvidersServingAsset, normalizeRampsAssetId, providerServesAsset, } from './providerAvailability.js';
+import { RAMPS_ERROR_CODES } from './rampsErrorCodes.js';
+import { RampsOrderStatus } from './RampsService.js';
+import { DEFAULT_REQUEST_CACHE_TTL, DEFAULT_REQUEST_CACHE_MAX_SIZE, createCacheKey, isCacheExpired, createLoadingState, createSuccessState, createErrorState, RequestStatus, } from './RequestCache.js';
+import { createInitialState as createInitialWalletRegistrationState, transition as transitionWalletRegistration, } from './wallet-registration-machine.js';
+import { createIdempotencyKey, WalletRegistrationError, } from './wallet-registration-service.js';
 // === GENERAL ===
 /**
  * The name of the {@link RampsController}, used to namespace the
@@ -83,12 +72,17 @@ export const RAMPS_CONTROLLER_REQUIRED_SERVICE_ACTIONS = [
  * `AuthenticationController:getSessionProfile` resolves the vendor customer
  * identity from Profile Sync, and `KeyringController:signPersonalMessage` signs
  * the EIP-191 ownership proof for Money Account self-hosted wallet
- * registration; both are only exercised by the autoramp paths.
+ * registration; both are only exercised by the autoramp paths. User Storage
+ * and authentication actions support cross-client order syncing.
  */
 export const RAMPS_CONTROLLER_REQUIRED_CONTROLLER_ACTIONS = [
     'AuthenticationController:getSessionProfile',
+    'AuthenticationController:isSignedIn',
     'KeyringController:signPersonalMessage',
     'RemoteFeatureFlagController:getState',
+    'UserStorageController:getState',
+    'UserStorageController:performGetStorageAllFeatureEntries',
+    'UserStorageController:performBatchSetStorage',
 ];
 /**
  * Distinguishes an already-materialized {@link AutorampAccount} from the
@@ -381,18 +375,22 @@ function findRegionFromCode(regionCode, countries) {
  */
 export function getInternalOrderCode(orderOrId) {
     if (typeof orderOrId === 'string') {
-        return orderOrId.includes('/orders/')
-            ? orderOrId.split('/orders/')[1]
-            : orderOrId;
+        if (orderOrId.includes('/orders/')) {
+            return orderOrId.split('/orders/')[1]?.trim() || '';
+        }
+        return orderOrId.trim();
     }
     const { id, providerOrderId } = orderOrId;
     if (id?.includes('/orders/')) {
-        return id.split('/orders/')[1];
+        const code = id.split('/orders/')[1]?.trim();
+        if (code) {
+            return code;
+        }
     }
-    return providerOrderId;
+    return providerOrderId?.trim() ?? '';
 }
 // === ORDER POLLING CONSTANTS ===
-const DEFAULT_POLLING_INTERVAL_MS = 30000;
+const DEFAULT_POLLING_INTERVAL_MS = 30_000;
 const MAX_ERROR_COUNT = 5;
 // === CONTROLLER DEFINITION ===
 const MESSENGER_EXPOSED_METHODS = [
@@ -454,6 +452,7 @@ const MESSENGER_EXPOSED_METHODS = [
     'transakCancelOrder',
     'transakCancelAllActiveOrders',
     'transakGetActiveOrders',
+    'syncOrdersWithUserStorage',
 ];
 /**
  * Whether controller state still describes the context a payment-method
@@ -476,6 +475,104 @@ function contextStillMatches(state, context) {
         (state.providers.selected?.id.trim() ?? '') === context.providerId);
 }
 export class RampsController extends BaseController {
+    /**
+     * Default TTL for cached requests.
+     */
+    #requestCacheTTL;
+    /**
+     * Maximum number of entries in the request cache.
+     */
+    #requestCacheMaxSize;
+    #onOrderSyncErroneousSituation;
+    #trace;
+    /**
+     * Map of pending requests for deduplication.
+     * Key is the cache key, value is the pending request with abort controller.
+     */
+    #pendingRequests = new Map();
+    /**
+     * Count of in-flight requests per resource type.
+     * Used so isLoading is only cleared when the last request for that resource finishes.
+     */
+    #pendingResourceCount = new Map();
+    /**
+     * Monotonic generation per resource type used to invalidate stale in-flight
+     * requests after region/token/provider dependent-resource resets.
+     */
+    #pendingResourceGeneration = new Map();
+    #orderPollingMeta = new Map();
+    #orderPollingTimer = null;
+    #isPolling = false;
+    #initPromise = null;
+    /**
+     * Semaphore that prevents sync feedback loops while applying remote order changes.
+     */
+    #isOrderSyncingInProgress = false;
+    /**
+     * Whether the full sync is applying its own local state changes.
+     */
+    #isApplyingOrderSyncChanges = false;
+    /**
+     * Orders deleted locally while a full sync held the semaphore.
+     */
+    #pendingRemoteDeletes = new Map();
+    /**
+     * Coalesces overlapping `syncOrdersWithUserStorage` calls into a follow-up run.
+     */
+    #orderSyncQueued = false;
+    #orderSyncPromise = null;
+    /**
+     * Whether a full order sync is currently applying remote changes.
+     *
+     * @returns Whether order sync is in progress.
+     */
+    get isOrderSyncingInProgress() {
+        return this.#isOrderSyncingInProgress;
+    }
+    /**
+     * Sets the order-syncing-in-progress semaphore.
+     * Used by the order-syncing module; hosts should not call this.
+     *
+     * @param value - Whether sync is in progress.
+     * @internal
+     */
+    setIsOrderSyncingInProgress(value) {
+        this.#isOrderSyncingInProgress = value;
+    }
+    /**
+     * Distinguishes full sync's own state changes from external mutations.
+     *
+     * @param value - Whether sync changes are being applied.
+     * @internal
+     */
+    setIsApplyingOrderSyncChanges(value) {
+        this.#isApplyingOrderSyncChanges = value;
+    }
+    /**
+     * Returns orders deleted while a full sync was in progress.
+     * Used by the order-syncing module.
+     *
+     * @returns Pending deletes for remote tombstone upload.
+     * @internal
+     */
+    getPendingRemoteDeletes() {
+        return [...this.#pendingRemoteDeletes.values()];
+    }
+    /**
+     * Clears deletes whose tombstones were successfully persisted. A delete
+     * replaced while a write was in flight remains pending.
+     *
+     * @param orders - Deletes included in a successful remote write.
+     * @internal
+     */
+    acknowledgePendingRemoteDeletes(orders) {
+        for (const order of orders) {
+            const key = getInternalOrderCode(order);
+            if (key && this.#pendingRemoteDeletes.get(key) === order) {
+                this.#pendingRemoteDeletes.delete(key);
+            }
+        }
+    }
     /**
      * Clears the pending resource count map. Used only in tests to exercise the
      * defensive path when get() returns undefined in the finally block.
@@ -483,7 +580,24 @@ export class RampsController extends BaseController {
      * @internal
      */
     clearPendingResourceCountForTest() {
-        __classPrivateFieldGet(this, _RampsController_pendingResourceCount, "f").clear();
+        this.#pendingResourceCount.clear();
+    }
+    #clearPendingResourceCountForDependentResources() {
+        for (const resourceType of DEPENDENT_RESOURCE_KEYS) {
+            this.#pendingResourceCount.delete(resourceType);
+            const generation = this.#pendingResourceGeneration.get(resourceType) ?? 0;
+            this.#pendingResourceGeneration.set(resourceType, generation + 1);
+        }
+    }
+    #abortDependentRequests() {
+        for (const [cacheKey, pending] of this.#pendingRequests.entries()) {
+            if (pending.resourceType &&
+                DEPENDENT_RESOURCE_KEYS_SET.has(pending.resourceType)) {
+                pending.abortController.abort();
+                this.#pendingRequests.delete(cacheKey);
+                this.#removeRequestState(cacheKey);
+            }
+        }
     }
     /**
      * Constructs a new {@link RampsController}.
@@ -494,8 +608,10 @@ export class RampsController extends BaseController {
      * controller. Missing properties will be filled in with defaults.
      * @param args.requestCacheTTL - Time to live for cached requests in milliseconds.
      * @param args.requestCacheMaxSize - Maximum number of entries in the request cache.
+     * @param args.onOrderSyncErroneousSituation - Optional order-sync error reporter.
+     * @param args.trace - Optional performance tracing callback for order sync.
      */
-    constructor({ messenger, state = {}, requestCacheTTL = DEFAULT_REQUEST_CACHE_TTL, requestCacheMaxSize = DEFAULT_REQUEST_CACHE_MAX_SIZE, }) {
+    constructor({ messenger, state = {}, requestCacheTTL = DEFAULT_REQUEST_CACHE_TTL, requestCacheMaxSize = DEFAULT_REQUEST_CACHE_MAX_SIZE, onOrderSyncErroneousSituation, trace, }) {
         super({
             messenger,
             metadata: rampsControllerMetadata,
@@ -507,38 +623,41 @@ export class RampsController extends BaseController {
                 requests: {},
             },
         });
-        _RampsController_instances.add(this);
-        /**
-         * Default TTL for cached requests.
-         */
-        _RampsController_requestCacheTTL.set(this, void 0);
-        /**
-         * Maximum number of entries in the request cache.
-         */
-        _RampsController_requestCacheMaxSize.set(this, void 0);
-        /**
-         * Map of pending requests for deduplication.
-         * 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());
-        /**
-         * Monotonic generation per resource type used to invalidate stale in-flight
-         * requests after region/token/provider dependent-resource resets.
-         */
-        _RampsController_pendingResourceGeneration.set(this, new Map());
-        _RampsController_orderPollingMeta.set(this, new Map());
-        _RampsController_orderPollingTimer.set(this, null);
-        _RampsController_isPolling.set(this, false);
-        _RampsController_initPromise.set(this, null);
-        __classPrivateFieldSet(this, _RampsController_requestCacheTTL, requestCacheTTL, "f");
-        __classPrivateFieldSet(this, _RampsController_requestCacheMaxSize, requestCacheMaxSize, "f");
+        this.#requestCacheTTL = requestCacheTTL;
+        this.#requestCacheMaxSize = requestCacheMaxSize;
+        this.#onOrderSyncErroneousSituation = onOrderSyncErroneousSituation;
+        this.#trace = trace;
         this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
     }
+    /**
+     * Resolves the Headless Buy all-providers feature flag: whether widening is
+     * enabled, and the provider-id allowlist the widened pick is restricted to
+     * (if the flag's object payload carries one).
+     *
+     * Reads `RemoteFeatureFlagController` state through the messenger on every
+     * call, so a remote flag fetch or a local dev override takes effect at
+     * runtime without reconstructing the controller. The single read keeps the
+     * enabled bit and the allowlist consistent even if the flag changes while a
+     * quote request is in flight. Key lookup, local-override merging, and value
+     * coercion live in the shared `isHeadlessAllProvidersEnabled` /
+     * `getHeadlessProviderAllowlist` helpers so UI consumers resolve the flag
+     * identically. Fails closed: when `RemoteFeatureFlagController:getState` is
+     * not wired up, quoting stays native-only.
+     *
+     * @returns The enabled bit and the optional provider-id allowlist.
+     */
+    #resolveAllProvidersFlag() {
+        try {
+            const remoteFeatureFlagState = this.messenger.call('RemoteFeatureFlagController:getState');
+            return {
+                enabled: isHeadlessAllProvidersEnabled(remoteFeatureFlagState),
+                allowlist: getHeadlessProviderAllowlist(remoteFeatureFlagState),
+            };
+        }
+        catch {
+            return { enabled: false };
+        }
+    }
     /**
      * Executes a request with caching, deduplication, and at most one in-flight
      * request per resource type.
@@ -565,11 +684,11 @@ export class RampsController extends BaseController {
      */
     async executeRequest(cacheKey, fetcher, options) {
         // Get TTL for verifying cache expiration
-        const ttl = options?.ttl ?? __classPrivateFieldGet(this, _RampsController_requestCacheTTL, "f");
+        const ttl = options?.ttl ?? this.#requestCacheTTL;
         // DEDUPLICATION:
         // Check if a request is already in flight for this cache key
         // If so, return the original promise for that request
-        const pending = __classPrivateFieldGet(this, _RampsController_pendingRequests, "f").get(cacheKey);
+        const pending = this.#pendingRequests.get(cacheKey);
         if (pending) {
             return pending.promise;
         }
@@ -587,17 +706,17 @@ export class RampsController extends BaseController {
         const lastFetchedAt = Date.now();
         const { resourceType } = options ?? {};
         const resourceGeneration = resourceType
-            ? (__classPrivateFieldGet(this, _RampsController_pendingResourceGeneration, "f").get(resourceType) ?? 0)
+            ? (this.#pendingResourceGeneration.get(resourceType) ?? 0)
             : undefined;
         // Update state to loading
-        __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_updateRequestState).call(this, cacheKey, createLoadingState());
+        this.#updateRequestState(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);
+            const count = this.#pendingResourceCount.get(resourceType) ?? 0;
+            this.#pendingResourceCount.set(resourceType, count + 1);
             if (count === 0) {
-                __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_setResourceLoading).call(this, resourceType, true);
+                this.#setResourceLoading(resourceType, true);
             }
         }
         // Create the fetch promise
@@ -607,11 +726,11 @@ export class RampsController extends BaseController {
                 if (abortController.signal.aborted) {
                     throw new Error('Request was aborted');
                 }
-                __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_updateRequestState).call(this, cacheKey, createSuccessState(data, lastFetchedAt));
+                this.#updateRequestState(cacheKey, createSuccessState(data, lastFetchedAt));
                 if (resourceType) {
                     const isCurrent = !options?.isResultCurrent || options.isResultCurrent();
                     if (isCurrent) {
-                        __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_setResourceError).call(this, resourceType, null);
+                        this.#setResourceError(resourceType, null);
                     }
                 }
                 return data;
@@ -621,38 +740,38 @@ export class RampsController extends BaseController {
                     throw error;
                 }
                 const { errorInfo, normalizedError } = getNormalizedRampsError(error);
-                __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_updateRequestState).call(this, cacheKey, createErrorState(errorInfo.message, lastFetchedAt, errorInfo.errorKey));
+                this.#updateRequestState(cacheKey, createErrorState(errorInfo.message, lastFetchedAt, errorInfo.errorKey));
                 if (resourceType) {
                     const isCurrent = !options?.isResultCurrent || options.isResultCurrent();
                     if (isCurrent) {
-                        __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_setResourceError).call(this, resourceType, errorInfo);
+                        this.#setResourceError(resourceType, errorInfo);
                     }
                 }
                 throw normalizedError;
             }
             finally {
-                if (__classPrivateFieldGet(this, _RampsController_pendingRequests, "f").get(cacheKey)?.abortController ===
+                if (this.#pendingRequests.get(cacheKey)?.abortController ===
                     abortController) {
-                    __classPrivateFieldGet(this, _RampsController_pendingRequests, "f").delete(cacheKey);
+                    this.#pendingRequests.delete(cacheKey);
                 }
                 // Clear resource-level loading state only when no requests for this resource remain
                 if (resourceType && !abortController.signal.aborted) {
-                    const currentGeneration = __classPrivateFieldGet(this, _RampsController_pendingResourceGeneration, "f").get(resourceType) ?? 0;
+                    const currentGeneration = this.#pendingResourceGeneration.get(resourceType) ?? 0;
                     if (currentGeneration === resourceGeneration) {
-                        const count = __classPrivateFieldGet(this, _RampsController_pendingResourceCount, "f").get(resourceType) ?? 0;
+                        const count = this.#pendingResourceCount.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);
+                            this.#pendingResourceCount.delete(resourceType);
+                            this.#setResourceLoading(resourceType, false);
                         }
                         else {
-                            __classPrivateFieldGet(this, _RampsController_pendingResourceCount, "f").set(resourceType, next);
+                            this.#pendingResourceCount.set(resourceType, next);
                         }
                     }
                 }
             }
         })();
-        __classPrivateFieldGet(this, _RampsController_pendingRequests, "f").set(cacheKey, {
+        this.#pendingRequests.set(cacheKey, {
             promise,
             abortController,
             resourceType,
@@ -666,15 +785,92 @@ export class RampsController extends BaseController {
      * @returns True if a request was aborted.
      */
     abortRequest(cacheKey) {
-        const pending = __classPrivateFieldGet(this, _RampsController_pendingRequests, "f").get(cacheKey);
+        const pending = this.#pendingRequests.get(cacheKey);
         if (pending) {
             pending.abortController.abort();
-            __classPrivateFieldGet(this, _RampsController_pendingRequests, "f").delete(cacheKey);
-            __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_removeRequestState).call(this, cacheKey);
+            this.#pendingRequests.delete(cacheKey);
+            this.#removeRequestState(cacheKey);
             return true;
         }
         return false;
     }
+    /**
+     * Mutates state.requests inside update(); cast is centralized here.
+     *
+     * @param fn - Callback that mutates the requests record.
+     */
+    #mutateRequests(fn) {
+        this.update((state) => {
+            const requests = state.requests;
+            fn(requests);
+        });
+    }
+    #removeRequestState(cacheKey) {
+        this.#mutateRequests((requests) => {
+            delete requests[cacheKey];
+        });
+    }
+    #cleanupState() {
+        this.#abortDependentRequests();
+        this.#clearPendingResourceCountForDependentResources();
+        this.update((state) => resetDependentResources(state, { clearUserRegionData: true }));
+    }
+    #requireRegion() {
+        const regionCode = this.state.userRegion?.regionCode;
+        if (!regionCode) {
+            throw new Error('Region is required. Cannot proceed without valid region information.');
+        }
+        return regionCode;
+    }
+    #isRegionCurrent(normalizedRegion) {
+        const current = this.state.userRegion?.regionCode;
+        return current === undefined || current === normalizedRegion;
+    }
+    #isTokenCurrent(normalizedAssetId) {
+        const current = this.state.tokens.selected?.assetId ?? '';
+        return current === normalizedAssetId;
+    }
+    #isProviderCurrent(normalizedProviderId) {
+        const current = this.state.providers.selected?.id ?? '';
+        return current === normalizedProviderId;
+    }
+    /**
+     * Updates a single field (isLoading or error) on a resource state.
+     * All resources share the same ResourceState structure, so we use
+     * dynamic property access to avoid duplicating switch statements.
+     *
+     * @param resourceType - The type of resource.
+     * @param field - The field to update ('isLoading' or 'error').
+     * @param value - The value to set.
+     */
+    #updateResourceField(resourceType, field, value) {
+        this.update((state) => {
+            const resource = getResourceState(state, resourceType);
+            resource[field] = value;
+        });
+    }
+    /**
+     * Sets the loading state for a resource type.
+     *
+     * @param resourceType - The type of resource.
+     * @param loading - Whether the resource is loading.
+     */
+    #setResourceLoading(resourceType, loading) {
+        this.#updateResourceField(resourceType, 'isLoading', loading);
+    }
+    /**
+     * Sets the error state for a resource type.
+     *
+     * @param resourceType - The type of resource.
+     * @param errorInfo - The error info, or null to clear.
+     */
+    #setResourceError(resourceType, errorInfo) {
+        this.update((state) => {
+            const resource = getResourceState(state, resourceType);
+            resource.error = errorInfo?.message ?? null;
+            resource.errorKey = errorInfo?.errorKey ?? null;
+        });
+    }
     /**
      * Gets the state of a specific cached request.
      *
@@ -684,6 +880,42 @@ export class RampsController extends BaseController {
     getRequestState(cacheKey) {
         return this.state.requests[cacheKey];
     }
+    /**
+     * Updates the state for a specific request.
+     *
+     * @param cacheKey - The cache key.
+     * @param requestState - The new state for the request.
+     */
+    #updateRequestState(cacheKey, requestState) {
+        const maxSize = this.#requestCacheMaxSize;
+        const ttl = this.#requestCacheTTL;
+        this.#mutateRequests((requests) => {
+            requests[cacheKey] = requestState;
+            const keys = Object.keys(requests);
+            for (const key of keys) {
+                const entry = requests[key];
+                if (entry?.status === RequestStatus.SUCCESS &&
+                    isCacheExpired(entry, ttl)) {
+                    delete requests[key];
+                }
+            }
+            const remainingKeys = Object.keys(requests);
+            if (remainingKeys.length > maxSize) {
+                const sortedKeys = remainingKeys.sort((a, b) => {
+                    const aTime = requests[a]?.timestamp ?? 0;
+                    const bTime = requests[b]?.timestamp ?? 0;
+                    return aTime - bTime;
+                });
+                const entriesToRemove = remainingKeys.length - maxSize;
+                for (let i = 0; i < entriesToRemove; i++) {
+                    const keyToRemove = sortedKeys[i];
+                    if (keyToRemove) {
+                        delete requests[keyToRemove];
+                    }
+                }
+            }
+        });
+    }
     /**
      * Sets the user's region manually (without fetching geolocation).
      * This allows users to override the detected region.
@@ -697,12 +929,12 @@ export class RampsController extends BaseController {
         try {
             const countriesData = this.state.countries.data;
             if (!countriesData || countriesData.length === 0) {
-                __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_cleanupState).call(this);
+                this.#cleanupState();
                 throw new Error('No countries found. Cannot set user region without valid country information.');
             }
             const userRegion = findRegionFromCode(normalizedRegion, countriesData);
             if (!userRegion) {
-                __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_cleanupState).call(this);
+                this.#cleanupState();
                 throw new Error(`Region "${normalizedRegion}" not found in countries data. Cannot set user region without valid country information.`);
             }
             const regionChanged = Boolean(options?.forceRefresh) ||
@@ -713,7 +945,7 @@ export class RampsController extends BaseController {
                 // user taps France → Finland → France quickly). Instead we let
                 // old requests complete naturally; isResultCurrent guards in
                 // getProviders/getPaymentMethods discard stale results.
-                __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_clearPendingResourceCountForDependentResources).call(this);
+                this.#clearPendingResourceCountForDependentResources();
             }
             this.update((state) => {
                 if (regionChanged) {
@@ -724,7 +956,7 @@ export class RampsController extends BaseController {
             return userRegion;
         }
         catch (error) {
-            __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_cleanupState).call(this);
+            this.#cleanupState();
             throw error;
         }
     }
@@ -749,7 +981,7 @@ export class RampsController extends BaseController {
             });
             return;
         }
-        __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_requireRegion).call(this);
+        this.#requireRegion();
         // If a full Provider object is passed, store it directly (avoids
         // depending on state.providers.data being populated).
         if (typeof providerOrId !== 'string') {
@@ -829,21 +1061,68 @@ export class RampsController extends BaseController {
      * @returns Promise that resolves when initialization is complete.
      */
     async init(options) {
-        if (!options?.forceRefresh && __classPrivateFieldGet(this, _RampsController_initPromise, "f") !== null) {
-            return __classPrivateFieldGet(this, _RampsController_initPromise, "f");
+        if (!options?.forceRefresh && this.#initPromise !== null) {
+            return this.#initPromise;
         }
         if (options?.forceRefresh) {
-            __classPrivateFieldSet(this, _RampsController_initPromise, null, "f");
+            this.#initPromise = null;
         }
-        const initPromise = __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_runInit).call(this, options).then(() => undefined, (error) => {
-            if (__classPrivateFieldGet(this, _RampsController_initPromise, "f") === initPromise) {
-                __classPrivateFieldSet(this, _RampsController_initPromise, null, "f");
+        const initPromise = this.#runInit(options).then(() => undefined, (error) => {
+            if (this.#initPromise === initPromise) {
+                this.#initPromise = null;
             }
             throw error;
         });
-        __classPrivateFieldSet(this, _RampsController_initPromise, initPromise, "f");
+        this.#initPromise = initPromise;
         return initPromise;
     }
+    async #runInit(options) {
+        // Force-refetch the catalog on startup so region preset amounts stay
+        // current, bypassing the in-session request cache. The catalog is not
+        // persisted, so a cold start always re-fetches it regardless.
+        await this.getCountries({ ...options, forceRefresh: true });
+        // Always prefer the user's persisted region. Geolocation is only used to
+        // seed the initial value; once the user (or a prior init) has set a region
+        // we must respect that choice — even on forceRefresh.
+        const persistedRegionCode = this.state.userRegion?.regionCode;
+        const regionCode = persistedRegionCode ??
+            (await this.messenger.call('RampsService:getGeolocation'));
+        if (!regionCode) {
+            throw new Error('Failed to fetch geolocation. Cannot initialize controller without valid region information.');
+        }
+        // For an already-persisted region, getCountries() has already re-synced it
+        // from the fresh catalog (see #syncUserRegionFromCountriesCatalog). Calling
+        // setUserRegion here would re-validate against that catalog and, if it is
+        // momentarily empty or no longer lists the region (e.g. a transient/partial
+        // catalog response or a region with no current provider coverage), throw and
+        // wipe the persisted region via #cleanupState. Preserve the existing region
+        // instead; only resolve a brand-new region (from geolocation) strictly.
+        if (persistedRegionCode) {
+            return;
+        }
+        await this.setUserRegion(regionCode, options);
+    }
+    /**
+     * Re-applies `userRegion` from the current countries catalog so preset
+     * amounts and support flags stay in sync after a catalog refresh.
+     */
+    #syncUserRegionFromCountriesCatalog() {
+        const regionCode = this.state.userRegion?.regionCode;
+        if (!regionCode) {
+            return;
+        }
+        const countriesData = this.state.countries.data;
+        if (!countriesData.length) {
+            return;
+        }
+        const userRegion = findRegionFromCode(regionCode, countriesData);
+        if (!userRegion) {
+            return;
+        }
+        this.update((state) => {
+            state.userRegion = userRegion;
+        });
+    }
     /**
      * Fetches the list of supported countries.
      * The API returns countries with support information for both buy and sell actions.
@@ -860,7 +1139,7 @@ export class RampsController extends BaseController {
         this.update((state) => {
             state.countries.data = Array.isArray(countries) ? [...countries] : [];
         });
-        __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_syncUserRegionFromCountriesCatalog).call(this);
+        this.#syncUserRegionFromCountriesCatalog();
         return countries;
     }
     /**
@@ -874,7 +1153,7 @@ export class RampsController extends BaseController {
      * @returns The tokens response containing topTokens and allTokens.
      */
     async getTokens(region, action = 'buy', options) {
-        const regionToUse = region ?? __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_requireRegion).call(this);
+        const regionToUse = region ?? this.#requireRegion();
         const normalizedRegion = regionToUse.toLowerCase().trim();
         const cacheKey = createCacheKey('getTokens', [
             normalizedRegion,
@@ -888,7 +1167,7 @@ export class RampsController extends BaseController {
         }, {
             ...options,
             resourceType: 'tokens',
-            isResultCurrent: () => __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_isRegionCurrent).call(this, normalizedRegion),
+            isResultCurrent: () => this.#isRegionCurrent(normalizedRegion),
         });
         this.update((state) => {
             const userRegionCode = state.userRegion?.regionCode;
@@ -913,7 +1192,7 @@ export class RampsController extends BaseController {
             });
             return;
         }
-        __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_requireRegion).call(this);
+        this.#requireRegion();
         const tokens = this.state.tokens.data;
         if (!tokens) {
             throw new Error('Tokens not loaded. Cannot set selected token before tokens are fetched.');
@@ -939,7 +1218,7 @@ export class RampsController extends BaseController {
      * @returns The providers response containing providers array.
      */
     async getProviders(region, options) {
-        const regionToUse = region ?? __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_requireRegion).call(this);
+        const regionToUse = region ?? this.#requireRegion();
         const normalizedRegion = regionToUse.toLowerCase().trim();
         const cacheKey = createCacheKey('getProviders', [
             normalizedRegion,
@@ -956,7 +1235,7 @@ export class RampsController extends BaseController {
         }, {
             ...options,
             resourceType: 'providers',
-            isResultCurrent: () => __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_isRegionCurrent).call(this, normalizedRegion),
+            isResultCurrent: () => this.#isRegionCurrent(normalizedRegion),
         });
         const { providers } = response;
         this.update((state) => {
@@ -978,7 +1257,7 @@ export class RampsController extends BaseController {
      * @returns The payment methods response containing payments array.
      */
     async getPaymentMethods(region, options) {
-        const regionCode = region ?? __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_requireRegion).call(this);
+        const regionCode = region ?? this.#requireRegion();
         const assetIdToUse = options?.assetId ?? this.state.tokens.selected?.assetId ?? '';
         const providerToUse = options?.provider ?? this.state.providers.selected?.id ?? '';
         const normalizedRegion = regionCode.toLowerCase().trim();
@@ -997,9 +1276,9 @@ export class RampsController extends BaseController {
             ...options,
             resourceType: 'paymentMethods',
             isResultCurrent: () => {
-                const regionMatch = __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_isRegionCurrent).call(this, normalizedRegion);
-                const tokenMatch = __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_isTokenCurrent).call(this, assetIdToUse);
-                const providerMatch = __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_isProviderCurrent).call(this, providerToUse);
+                const regionMatch = this.#isRegionCurrent(normalizedRegion);
+                const tokenMatch = this.#isTokenCurrent(assetIdToUse);
+                const providerMatch = this.#isProviderCurrent(providerToUse);
                 return regionMatch && tokenMatch && providerMatch;
             },
         });
@@ -1062,7 +1341,7 @@ export class RampsController extends BaseController {
      *   provider ids that contributed.
      */
     async getPaymentMethodsForContext(options) {
-        const regionToUse = options.region ?? __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_requireRegion).call(this);
+        const regionToUse = options.region ?? this.#requireRegion();
         const normalizedRegion = regionToUse.toLowerCase().trim();
         const assetId = options.assetId.trim();
         if (assetId === '') {
@@ -1073,7 +1352,7 @@ export class RampsController extends BaseController {
         const providerIdForState = options.providers?.length === 1
             ? options.providers[0].trim()
             : (this.state.providers.selected?.id.trim() ?? '');
-        const providerIds = await __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_resolveProviderIdsForPaymentMethods).call(this, {
+        const providerIds = await this.#resolveProviderIdsForPaymentMethods({
             assetId,
             region: normalizedRegion,
             providers: options.providers,
@@ -1225,7 +1504,7 @@ export class RampsController extends BaseController {
      * @returns The quotes response containing success, sorted, error, and customActions.
      */
     async getQuotes(options) {
-        const regionToUse = options.region ?? __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_requireRegion).call(this);
+        const regionToUse = options.region ?? this.#requireRegion();
         const fiatToUse = options.fiat ?? this.state.userRegion?.country?.currency;
         const paymentMethodsToUse = options.paymentMethods ??
             this.state.paymentMethods.data.map((pm) => pm.id);
@@ -1250,14 +1529,14 @@ export class RampsController extends BaseController {
         // the same `RemoteFeatureFlagController` state snapshot, so a flag edit
         // during the awaited quote fetch cannot produce a mixed read.
         const { enabled: allProvidersEnabled, allowlist: providerAllowlist } = wantsAutoSelection
-            ? __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_resolveAllProvidersFlag).call(this)
+            ? this.#resolveAllProvidersFlag()
             : { enabled: false, allowlist: undefined };
         const widenToAllProviders = wantsAutoSelection && allProvidersEnabled;
         let providersToUse;
         let widenedProviderCatalog = this.state.providers.data;
         if (options.providers) {
             providersToUse = options.restrictToKnownOrNativeProviders
-                ? await __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_filterProviderIdsBySupport).call(this, {
+                ? await this.#filterProviderIdsBySupport({
                     providerIds: options.providers,
                     assetId: normalizedAssetIdForValidation,
                     region: regionToUse,
@@ -1268,7 +1547,7 @@ export class RampsController extends BaseController {
             // `#getSupportingProvidersForRegion` also hydrates the provider catalog
             // when controller state is empty, so all-provider quoting cannot silently
             // return zero providers here.
-            const { supporting } = await __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getSupportingProvidersForRegion).call(this, {
+            const { supporting } = await this.#getSupportingProvidersForRegion({
                 assetId: normalizedAssetIdForValidation,
                 region: regionToUse,
             });
@@ -1280,7 +1559,7 @@ export class RampsController extends BaseController {
             // 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, {
+            providersToUse = await this.#resolveProviderIdsForQuote({
                 assetId: normalizedAssetIdForValidation,
                 region: regionToUse,
                 preferredProviderIds: options.preferredProviderIds,
@@ -1363,7 +1642,7 @@ export class RampsController extends BaseController {
         // and place it at `success[0]`, since single-pick consumers
         // (`getRampsQuote` -> `success?.[0]`) rely on index 0 while `success[]`
         // order is server-defined rather than ranked.
-        const selectedQuote = __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_pickWidenedQuote).call(this, response, {
+        const selectedQuote = this.#pickWidenedQuote(response, {
             amount: options.amount,
             fiat: normalizedFiat,
             providers: widenedProviderCatalog,
@@ -1387,23 +1666,320 @@ export class RampsController extends BaseController {
             ],
         };
     }
+    /**
+     * Selects the best quote from a widened multi-provider response.
+     *
+     * Every provider class is eligible (native, in-app WebView aggregator, and
+     * external-browser / custom-action). When the feature flag payload carries a
+     * provider allowlist, candidates from unlisted providers are dropped first.
+     * Enforces per-provider fiat limits up front, then orders by reliability and
+     * falls back to price using the server-provided `sorted` order. Returns
+     * `undefined` when no quote survives.
+     *
+     * @param response - The multi-provider quotes response.
+     * @param options - Selection inputs.
+     * @param options.amount - Fiat amount, for the limit-fit check.
+     * @param options.fiat - Lowercased fiat short code, for the limit lookup.
+     * @param options.providers - Provider catalog for the limit lookup.
+     * @param options.allowlist - Optional provider ids (either `/providers/x`
+     * or bare form) the pick is restricted to.
+     * @returns The selected quote, or `undefined` when none is usable.
+     */
+    #pickWidenedQuote(response, { amount, fiat, providers, allowlist, }) {
+        const providerByCode = new Map(providers.map((provider) => [provider.id, provider]));
+        const allowedProviderIds = allowlist && allowlist.length > 0
+            ? new Set(allowlist.map(normalizeHeadlessProviderId))
+            : undefined;
+        const isAllowedProvider = (quote) => !allowedProviderIds ||
+            allowedProviderIds.has(normalizeHeadlessProviderId(quote.provider));
+        const fitsProviderLimits = (quote) => {
+            const provider = providerByCode.get(quote.provider);
+            const limit = provider?.limits?.fiat?.[fiat]?.[quote.quote.paymentMethod];
+            if (!limit) {
+                // No published limits for this provider/payment method: treat as
+                // eligible and let the provider enforce limits at checkout.
+                return true;
+            }
+            return amount >= limit.minAmount && amount <= limit.maxAmount;
+        };
+        const candidates = response.success.filter((quote) => isAllowedProvider(quote) && fitsProviderLimits(quote));
+        if (candidates.length === 0) {
+            return undefined;
+        }
+        const candidateByCode = new Map(candidates.map((quote) => [quote.provider, quote]));
+        const pickBySortOrder = (sortBy) => {
+            const order = response.sorted.find((entry) => entry.sortBy === sortBy)?.ids;
+            if (!order) {
+                return undefined;
+            }
+            for (const providerId of order) {
+                const match = candidateByCode.get(providerId);
+                if (match) {
+                    return match;
+                }
+            }
+            return undefined;
+        };
+        // Reliability first, then price, then the first surviving candidate.
+        return (pickBySortOrder('reliability') ??
+            pickBySortOrder('price') ??
+            candidates[0]);
+    }
+    /**
+     * 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 #getSupportingProvidersForRegion({ assetId, region, }) {
+        const normalizedRegion = region.toLowerCase().trim();
+        let providers;
+        if (this.#isRegionCurrent(normalizedRegion) &&
+            this.state.providers.data.length > 0) {
+            providers = this.state.providers.data;
+        }
+        else {
+            ({ providers } = await this.getProviders(normalizedRegion));
+        }
+        // Case-insensitive CAIP-19 matching is shared with headless-buy consumers
+        // via `getProvidersServingAsset`, so the controller and the UI region gate
+        // cannot disagree about which providers serve the asset.
+        const supporting = getProvidersServingAsset(providers, assetId);
+        return { supporting, all: providers };
+    }
+    /**
+     * 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 #filterProviderIdsBySupport({ providerIds, assetId, region, }) {
+        const { supporting } = await this.#getSupportingProvidersForRegion({
+            assetId,
+            region,
+        });
+        const supportingIds = new Set(supporting.map((provider) => provider.id));
+        return providerIds.filter((id) => supportingIds.has(id));
+    }
+    /**
+     * 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 #resolveProviderIdsForQuote({ assetId, region, preferredProviderIds, restrictToKnownOrNative, }) {
+        const { supporting, all } = await this.#getSupportingProvidersForRegion({
+            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 ?? this.#getPreferredProviderIdsFromOrders();
+        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];
+    }
+    /**
+     * Resolves provider IDs that should contribute payment methods for a
+     * quoting context. Mirrors {@link getQuotes} provider-set selection, with
+     * one intentional difference on the widened path: when the all-providers
+     * flag allowlist is non-empty, returns supporting providers intersected
+     * with that allowlist (pick survivors for the picker). Does not mutate
+     * state.
+     *
+     * @param options - Resolution inputs aligned with `getQuotes`.
+     * @param options.assetId - CAIP-19 asset type identifier to resolve for.
+     * @param options.region - Region to resolve providers for.
+     * @param options.providers - Explicit provider IDs, when provided.
+     * @param options.autoSelectProvider - Resolve providers like `getQuotes`.
+     * @param options.preferredProviderIds - Preferred provider IDs in order.
+     * @param options.restrictToKnownOrNativeProviders - Headless gating.
+     * @returns Provider IDs for this request only.
+     */
+    async #resolveProviderIdsForPaymentMethods({ assetId, region, providers, autoSelectProvider, preferredProviderIds, restrictToKnownOrNativeProviders, }) {
+        const wantsAutoSelection = !providers &&
+            (autoSelectProvider === true ||
+                restrictToKnownOrNativeProviders === true);
+        const { enabled: allProvidersEnabled, allowlist: providerAllowlist } = wantsAutoSelection
+            ? this.#resolveAllProvidersFlag()
+            : { enabled: false, allowlist: undefined };
+        const widenToAllProviders = wantsAutoSelection && allProvidersEnabled;
+        if (providers) {
+            return restrictToKnownOrNativeProviders
+                ? this.#filterProviderIdsBySupport({
+                    providerIds: providers,
+                    assetId,
+                    region,
+                })
+                : providers;
+        }
+        if (widenToAllProviders) {
+            const { supporting } = await this.#getSupportingProvidersForRegion({
+                assetId,
+                region,
+            });
+            if (providerAllowlist && providerAllowlist.length > 0) {
+                const allowedProviderIds = new Set(providerAllowlist.map(normalizeHeadlessProviderId));
+                return supporting
+                    .filter((provider) => allowedProviderIds.has(normalizeHeadlessProviderId(provider.id)))
+                    .map((provider) => provider.id);
+            }
+            return supporting.map((provider) => provider.id);
+        }
+        if (autoSelectProvider || restrictToKnownOrNativeProviders) {
+            return this.#resolveProviderIdsForQuote({
+                assetId,
+                region,
+                preferredProviderIds,
+                restrictToKnownOrNative: restrictToKnownOrNativeProviders,
+            });
+        }
+        const selectedId = this.state.providers.selected?.id;
+        return selectedId ? [selectedId] : [];
+    }
+    /**
+     * Derives an ordered list of provider IDs from the user's completed-order
+     * history, most recently completed first, with duplicates removed.
+     *
+     * Reads only this controller's own normalized order state, so it carries no
+     * dependency on any client-specific order representation.
+     *
+     * @returns Provider IDs ordered by most recent completed order.
+     */
+    #getPreferredProviderIdsFromOrders() {
+        const orderedIds = [];
+        const completedOrders = this.state.orders
+            .filter((order) => order.status === 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;
+    }
     // === ORDER MANAGEMENT ===
     /**
      * Adds or updates a V2 order in controller state.
      * If an order with the same internal order code already exists, the incoming
      * fields are merged on top of the existing order so that fields not present
      * in the update (e.g. paymentDetails from the Transak API) are preserved.
+     * Unchanged syncable payloads (including unchanged poll results) are ignored
+     * so `lastUpdatedAt` is not bumped and User Storage is not rewritten.
      *
      * @param order - The RampsOrder to add or update.
      */
     addOrder(order) {
         const internalOrderCode = getInternalOrderCode(order);
+        if (!internalOrderCode) {
+            this.#onOrderSyncErroneousSituation?.('Unable to derive internal order code for addOrder', {});
+            return;
+        }
+        const existing = this.state.orders.find((existingOrder) => getInternalOrderCode(existingOrder) === internalOrderCode);
+        if (existing &&
+            !this.#isApplyingOrderSyncChanges &&
+            areOrdersEqual(existing, order)) {
+            // Syncable payload unchanged; check if paymentDetails differ.
+            // paymentDetails is local-only (never synced remotely), so if it's the
+            // only change we merge it without bumping lastUpdatedAt or writing remotely.
+            if (order.paymentDetails &&
+                JSON.stringify(existing.paymentDetails) !==
+                    JSON.stringify(order.paymentDetails)) {
+                this.update((state) => {
+                    const idx = state.orders.findIndex((stateOrder) => getInternalOrderCode(stateOrder) === internalOrderCode);
+                    if (idx !== -1) {
+                        state.orders[idx] = {
+                            ...state.orders[idx],
+                            paymentDetails: order.paymentDetails,
+                        };
+                    }
+                });
+            }
+            return;
+        }
+        const incomingLastUpdatedAt = order.lastUpdatedAt;
+        // Local edits always bump lastUpdatedAt so full-sync LWW can prefer them
+        // over stale remote copies when an incremental push was skipped/failed.
+        // This includes external edits mid-sync (e.g. polling via `getOrder`),
+        // which the queued follow-up sync must not lose under LWW.
+        // Only when sync applies its own imported orders do we preserve the remote
+        // `lu` / `createdAt` (never invent "now" for missing `lu`, or stale remotes
+        // win later LWW comparisons).
         const healedOrder = {
             ...order,
             providerOrderId: internalOrderCode,
+            lastUpdatedAt: this.#isApplyingOrderSyncChanges
+                ? (incomingLastUpdatedAt ?? order.createdAt ?? 0)
+                : Date.now(),
         };
+        if (!this.#isApplyingOrderSyncChanges) {
+            this.#pendingRemoteDeletes.delete(internalOrderCode);
+        }
         this.update((state) => {
-            const idx = state.orders.findIndex((existing) => getInternalOrderCode(existing) === internalOrderCode);
+            const idx = state.orders.findIndex((stateOrder) => getInternalOrderCode(stateOrder) === internalOrderCode);
             if (idx === -1) {
                 state.orders.push(healedOrder);
             }
@@ -1414,6 +1990,22 @@ export class RampsController extends BaseController {
                 };
             }
         });
+        if (this.#isOrderSyncingInProgress && !this.#isApplyingOrderSyncChanges) {
+            // Incremental push is suppressed during full sync; queue another full
+            // sync pass so mutations during the upload await are not dropped.
+            this.#orderSyncQueued = true;
+        }
+        else if (!this.#isOrderSyncingInProgress) {
+            updateOrderInUserStorage(healedOrder, {
+                getRampsControllerInstance: () => this,
+                getMessenger: () => this.messenger,
+            }, {
+                onOrderSyncErroneousSituation: this.#onOrderSyncErroneousSituation,
+            }).catch((error) => {
+                console.error('Error updating ramps order in remote storage:', error);
+                this.#onOrderSyncErroneousSituation?.('Error updating ramps order in remote storage', { error });
+            });
+        }
     }
     /**
      * Removes a V2 order from controller state by providerOrderId.
@@ -1421,10 +2013,101 @@ export class RampsController extends BaseController {
      * @param providerOrderId - The provider order ID to remove.
      */
     removeOrder(providerOrderId) {
+        const orderToRemove = this.state.orders.find((order) => order.providerOrderId === providerOrderId ||
+            getInternalOrderCode(order) === providerOrderId);
         this.update((state) => {
-            state.orders = state.orders.filter((order) => order.providerOrderId !== providerOrderId);
+            state.orders = state.orders.filter((order) => order.providerOrderId !== providerOrderId &&
+                getInternalOrderCode(order) !== providerOrderId);
         });
-        __classPrivateFieldGet(this, _RampsController_orderPollingMeta, "f").delete(providerOrderId);
+        this.#orderPollingMeta.delete(providerOrderId);
+        if (orderToRemove) {
+            if (orderToRemove.providerOrderId) {
+                this.#orderPollingMeta.delete(orderToRemove.providerOrderId);
+            }
+            const internalOrderCode = getInternalOrderCode(orderToRemove);
+            this.#orderPollingMeta.delete(internalOrderCode);
+        }
+        if (orderToRemove) {
+            const deleteKey = getInternalOrderCode(orderToRemove);
+            const isLocalDeletion = !this.#isApplyingOrderSyncChanges;
+            if (isLocalDeletion && deleteKey) {
+                // Retain the delete until a full sync confirms its tombstone was
+                // persisted. This prevents a failed incremental write from allowing
+                // the still-active remote copy to be imported again.
+                this.#pendingRemoteDeletes.set(deleteKey, orderToRemove);
+            }
+            if (this.#isOrderSyncingInProgress) {
+                if (isLocalDeletion) {
+                    // Incremental remote deletes are gated off during full sync; queue a
+                    // tombstone write and another full sync pass so deletes during the
+                    // upload await are not dropped.
+                    this.#orderSyncQueued = true;
+                }
+            }
+            else if (isLocalDeletion) {
+                deleteOrderInUserStorage(orderToRemove, {
+                    getRampsControllerInstance: () => this,
+                    getMessenger: () => this.messenger,
+                }, {
+                    onOrderSyncErroneousSituation: this.#onOrderSyncErroneousSituation,
+                }).catch((error) => {
+                    console.error('Error deleting ramps order from remote storage:', error);
+                    this.#onOrderSyncErroneousSituation?.('Error deleting ramps order from remote storage', { error });
+                });
+            }
+        }
+    }
+    /**
+     * Bidirectionally syncs V2 ramps orders with User Storage.
+     * Hosts should call this on unlock / when ramps syncing is enabled.
+     *
+     * Overlapping calls are coalesced into the in-flight worker. After the worker
+     * settles, this method loops when `#orderSyncQueued` is still set so a
+     * request that arrived between the worker's last loop check and promise
+     * resolution is not dropped.
+     */
+    async syncOrdersWithUserStorage() {
+        this.#orderSyncQueued = true;
+        let syncError;
+        while (this.#orderSyncQueued || this.#orderSyncPromise) {
+            if (this.#orderSyncPromise) {
+                try {
+                    await this.#orderSyncPromise;
+                }
+                catch (error) {
+                    syncError ??=
+                        error instanceof Error ? error : new Error(String(error));
+                }
+                continue;
+            }
+            this.#orderSyncPromise = (async () => {
+                while (this.#orderSyncQueued) {
+                    this.#orderSyncQueued = false;
+                    await syncOrdersWithUserStorageInternal({
+                        onOrderSyncErroneousSituation: this.#onOrderSyncErroneousSituation,
+                    }, {
+                        getRampsControllerInstance: () => this,
+                        getMessenger: () => this.messenger,
+                        trace: this.#trace,
+                    });
+                }
+                // Yield so a caller can set `#orderSyncQueued` after the inner while
+                // check and still be observed by the outer loop.
+                await Promise.resolve();
+            })();
+            try {
+                await this.#orderSyncPromise;
+            }
+            catch (error) {
+                syncError ??= error instanceof Error ? error : new Error(String(error));
+            }
+            finally {
+                this.#orderSyncPromise = null;
+            }
+        }
+        if (syncError) {
+            throw syncError;
+        }
     }
     /**
      * Adds or updates a local autoramp last-seen cursor (e.g. after create).
@@ -1468,7 +2151,7 @@ export class RampsController extends BaseController {
         const customerId = await this.resolveAutorampCustomerId();
         const body = { ...request, customer_id: customerId };
         const remote = await this.messenger.call('NeoBankService:createAutoramp', body, options);
-        return __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_applyAutorampRemoteSnapshot).call(this, remote);
+        return this.#applyAutorampRemoteSnapshot(remote);
     }
     /**
      * Resolves the vendor `customer_id` for autoramp / Money Account operations.
@@ -1687,7 +2370,7 @@ export class RampsController extends BaseController {
      * @returns The updated local account.
      */
     applyAutorampStatusFromPush(remote) {
-        return __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_applyAutorampRemoteSnapshot).call(this, remote);
+        return this.#applyAutorampRemoteSnapshot(remote);
     }
     /**
      * Fetches one autoramp from the neo-bank proxy and applies it to the
@@ -1700,7 +2383,7 @@ export class RampsController extends BaseController {
      */
     async refreshAutoramp(autorampId) {
         const remote = await this.messenger.call('NeoBankService:getAutoramp', autorampId);
-        return __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_applyAutorampRemoteSnapshot).call(this, remote, { allowInsert: false });
+        return this.#applyAutorampRemoteSnapshot(remote, { allowInsert: false });
     }
     /**
      * Refreshes all known local autoramps from MoonPay.
@@ -1724,27 +2407,137 @@ export class RampsController extends BaseController {
         }
         return updated;
     }
+    /**
+     * Applies a remote snapshot to the last-seen cursor.
+     *
+     * @param remote - MoonPay snapshot.
+     * @param options - Apply options.
+     * @param options.allowInsert - When false, a missing local cursor is not
+     * recreated (used by refresh so a concurrent `removeAutoramp` wins).
+     * @returns The applied account. When `allowInsert` is false and no local
+     * cursor exists, the snapshot is returned without writing state.
+     */
+    #applyAutorampRemoteSnapshot(remote, { allowInsert = true } = {}) {
+        const local = this.state.autoramps.find((autoramp) => autoramp.id === remote.id) ??
+            null;
+        if (local === null && !allowInsert) {
+            return applyAutorampRemoteStatus(null, remote).account;
+        }
+        const result = applyAutorampRemoteStatus(local, remote);
+        this.update((state) => {
+            const idx = state.autoramps.findIndex((autoramp) => autoramp.id === result.account.id);
+            if (idx === -1) {
+                state.autoramps.push(result.account);
+            }
+            else {
+                state.autoramps[idx] = result.account;
+            }
+        });
+        if (result.statusChanged) {
+            this.messenger.publish('RampsController:autorampStatusChanged', {
+                autoramp: result.account,
+                previousStatus: result.previousStatus,
+                shouldNotify: result.shouldNotify,
+            });
+        }
+        return (this.state.autoramps.find((autoramp) => autoramp.id === result.account.id) ?? result.account);
+    }
+    /**
+     * Refreshes a single order via the V2 API and updates it in state.
+     * Publishes orderStatusChanged if the status transitioned.
+     *
+     * @param order - The order to refresh (needs provider and providerOrderId).
+     */
+    async #refreshOrder(order) {
+        const providerCode = order.provider?.id ?? '';
+        if (!providerCode || !order.providerOrderId || !order.walletAddress) {
+            return;
+        }
+        const previousStatus = order.status;
+        try {
+            const updatedOrder = await this.getOrder(providerCode, order.providerOrderId, order.walletAddress);
+            const meta = this.#orderPollingMeta.get(order.providerOrderId) ?? {
+                lastTimeFetched: 0,
+                errorCount: 0,
+            };
+            if (updatedOrder.status === RampsOrderStatus.Unknown) {
+                meta.errorCount = Math.min(meta.errorCount + 1, MAX_ERROR_COUNT);
+            }
+            else {
+                meta.errorCount = 0;
+            }
+            meta.lastTimeFetched = Date.now();
+            this.#orderPollingMeta.set(order.providerOrderId, meta);
+            if (previousStatus !== updatedOrder.status &&
+                previousStatus !== undefined) {
+                this.messenger.publish('RampsController:orderStatusChanged', {
+                    order: updatedOrder,
+                    previousStatus,
+                });
+            }
+            if (TERMINAL_ORDER_STATUSES.has(updatedOrder.status)) {
+                this.#orderPollingMeta.delete(order.providerOrderId);
+            }
+        }
+        catch {
+            const meta = this.#orderPollingMeta.get(order.providerOrderId) ?? {
+                lastTimeFetched: 0,
+                errorCount: 0,
+            };
+            meta.errorCount = Math.min(meta.errorCount + 1, MAX_ERROR_COUNT);
+            meta.lastTimeFetched = Date.now();
+            this.#orderPollingMeta.set(order.providerOrderId, meta);
+        }
+    }
     /**
      * Starts polling all pending V2 orders at a fixed interval.
      * Each poll cycle iterates orders with non-terminal statuses,
      * respects pollingSecondsMinimum and backoff from error count.
      */
     startOrderPolling() {
-        if (__classPrivateFieldGet(this, _RampsController_orderPollingTimer, "f")) {
+        if (this.#orderPollingTimer) {
             return;
         }
-        __classPrivateFieldSet(this, _RampsController_orderPollingTimer, setInterval(() => {
-            __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_pollPendingOrders).call(this).catch(() => undefined);
-        }, DEFAULT_POLLING_INTERVAL_MS), "f");
-        __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_pollPendingOrders).call(this).catch(() => undefined);
+        this.#orderPollingTimer = setInterval(() => {
+            this.#pollPendingOrders().catch(() => undefined);
+        }, DEFAULT_POLLING_INTERVAL_MS);
+        this.#pollPendingOrders().catch(() => undefined);
     }
     /**
      * Stops order polling and clears the interval.
      */
     stopOrderPolling() {
-        if (__classPrivateFieldGet(this, _RampsController_orderPollingTimer, "f")) {
-            clearInterval(__classPrivateFieldGet(this, _RampsController_orderPollingTimer, "f"));
-            __classPrivateFieldSet(this, _RampsController_orderPollingTimer, null, "f");
+        if (this.#orderPollingTimer) {
+            clearInterval(this.#orderPollingTimer);
+            this.#orderPollingTimer = null;
+        }
+    }
+    async #pollPendingOrders() {
+        if (this.#isPolling) {
+            return;
+        }
+        this.#isPolling = true;
+        try {
+            const pendingOrders = this.state.orders.filter((order) => PENDING_ORDER_STATUSES.has(order.status));
+            const now = Date.now();
+            await Promise.allSettled(pendingOrders.map(async (order) => {
+                const meta = this.#orderPollingMeta.get(order.providerOrderId);
+                if (meta) {
+                    const backoffMs = meta.errorCount > 0
+                        ? Math.min(DEFAULT_POLLING_INTERVAL_MS *
+                            Math.pow(2, meta.errorCount - 1), 5 * 60 * 1000)
+                        : 0;
+                    const pollingMinMs = (order.pollingSecondsMinimum ?? 0) * 1000;
+                    const minWait = Math.max(backoffMs, pollingMinMs);
+                    if (now - meta.lastTimeFetched < minWait) {
+                        return;
+                    }
+                }
+                await this.#refreshOrder(order);
+            }));
+        }
+        finally {
+            this.#isPolling = false;
         }
     }
     /**
@@ -1835,6 +2628,7 @@ export class RampsController extends BaseController {
      * @returns The unified order data.
      */
     async getOrder(providerCode, orderCode, wallet) {
+        const hadOrderAtRequestStart = this.state.orders.some((existingOrder) => getInternalOrderCode(existingOrder) === orderCode);
         const order = await this.messenger.call('RampsService:getOrder', providerCode, orderCode, wallet);
         const healedWalletAddress = order.walletAddress || wallet;
         const internalOrderCode = getInternalOrderCode({
@@ -1846,18 +2640,12 @@ export class RampsController extends BaseController {
             walletAddress: healedWalletAddress,
             providerOrderId: internalOrderCode,
         };
-        this.update((state) => {
-            const idx = state.orders.findIndex((existing) => getInternalOrderCode(existing) === internalOrderCode);
-            if (idx === -1) {
-                state.orders.push(healedOrder);
-            }
-            else {
-                state.orders[idx] = {
-                    ...state.orders[idx],
-                    ...healedOrder,
-                };
-            }
-        });
+        const orderStillExists = this.state.orders.some((existingOrder) => getInternalOrderCode(existingOrder) === internalOrderCode);
+        // A polling request can finish after removeOrder. Do not let that stale
+        // response recreate the local order and overwrite its remote tombstone.
+        if (!hadOrderAtRequestStart || orderStillExists) {
+            this.addOrder(healedOrder);
+        }
         return healedOrder;
     }
     /**
@@ -1875,6 +2663,30 @@ export class RampsController extends BaseController {
         const order = await this.messenger.call('RampsService:getOrderFromCallback', providerCode, callbackUrl, wallet);
         return order;
     }
+    // === TRANSAK METHODS ===
+    //
+    // Auth state is managed at two levels:
+    // - TransakService stores the access token (needed for API calls)
+    // - RampsController stores isAuthenticated (needed for UI state)
+    // Both are kept in sync by the controller methods below.
+    /**
+     * Checks whether an error is a 401 HTTP error (expired/missing token) and,
+     * if so, marks the Transak session as unauthenticated so the UI stays in
+     * sync with the cleared token inside TransakService.
+     *
+     * @param error - The caught error to inspect.
+     */
+    #syncTransakAuthOnError(error) {
+        if (hasHttpStatus(error) && error.httpStatus === 401) {
+            this.transakSetAuthenticated(false);
+        }
+    }
+    #getNormalizedTransakError(error, options = {}) {
+        if (options.syncAuth) {
+            this.#syncTransakAuthOnError(error);
+        }
+        return getNormalizedRampsError(error);
+    }
     /**
      * Sets the Transak API key used for all Transak API requests.
      *
@@ -1930,7 +2742,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:sendUserOtp', email);
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error).normalizedError;
+            throw this.#getNormalizedTransakError(error).normalizedError;
         }
     }
     /**
@@ -1949,7 +2761,7 @@ export class RampsController extends BaseController {
             return token;
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error).normalizedError;
+            throw this.#getNormalizedTransakError(error).normalizedError;
         }
     }
     /**
@@ -1963,7 +2775,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:logout');
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error).normalizedError;
+            throw this.#getNormalizedTransakError(error).normalizedError;
         }
         finally {
             this.transakClearAccessToken();
@@ -1993,7 +2805,7 @@ export class RampsController extends BaseController {
             return details;
         }
         catch (error) {
-            const { errorInfo, normalizedError } = __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error, {
+            const { errorInfo, normalizedError } = this.#getNormalizedTransakError(error, {
                 syncAuth: true,
             });
             this.update((state) => {
@@ -2030,7 +2842,7 @@ export class RampsController extends BaseController {
             return quote;
         }
         catch (error) {
-            const { errorInfo, normalizedError } = __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error);
+            const { errorInfo, normalizedError } = this.#getNormalizedTransakError(error);
             this.update((state) => {
                 state.nativeProviders.transak.buyQuote.isLoading = false;
                 state.nativeProviders.transak.buyQuote.error = errorInfo.message;
@@ -2061,7 +2873,7 @@ export class RampsController extends BaseController {
             return requirement;
         }
         catch (error) {
-            const { errorInfo, normalizedError } = __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error, {
+            const { errorInfo, normalizedError } = this.#getNormalizedTransakError(error, {
                 syncAuth: true,
             });
             this.update((state) => {
@@ -2084,7 +2896,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:getAdditionalRequirements', quoteId);
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error, { syncAuth: true })
+            throw this.#getNormalizedTransakError(error, { syncAuth: true })
                 .normalizedError;
         }
     }
@@ -2102,7 +2914,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:createOrder', quoteId, walletAddress, paymentMethodId);
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error, { syncAuth: true })
+            throw this.#getNormalizedTransakError(error, { syncAuth: true })
                 .normalizedError;
         }
     }
@@ -2119,7 +2931,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:getOrder', orderId, wallet, paymentDetails);
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error).normalizedError;
+            throw this.#getNormalizedTransakError(error).normalizedError;
         }
     }
     /**
@@ -2135,7 +2947,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:getUserLimits', fiatCurrency, paymentMethod, kycType);
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error, { syncAuth: true })
+            throw this.#getNormalizedTransakError(error, { syncAuth: true })
                 .normalizedError;
         }
     }
@@ -2149,7 +2961,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:requestOtt');
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error, { syncAuth: true })
+            throw this.#getNormalizedTransakError(error, { syncAuth: true })
                 .normalizedError;
         }
     }
@@ -2180,7 +2992,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:createWidgetUrl', quote, walletAddress, extraParams);
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error, { syncAuth: true })
+            throw this.#getNormalizedTransakError(error, { syncAuth: true })
                 .normalizedError;
         }
     }
@@ -2195,7 +3007,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:submitPurposeOfUsageForm', purpose);
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error, { syncAuth: true })
+            throw this.#getNormalizedTransakError(error, { syncAuth: true })
                 .normalizedError;
         }
     }
@@ -2210,7 +3022,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:patchUser', data);
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error, { syncAuth: true })
+            throw this.#getNormalizedTransakError(error, { syncAuth: true })
                 .normalizedError;
         }
     }
@@ -2226,7 +3038,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:submitSsnDetails', ssn, quoteId);
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error, { syncAuth: true })
+            throw this.#getNormalizedTransakError(error, { syncAuth: true })
                 .normalizedError;
         }
     }
@@ -2242,7 +3054,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:confirmPayment', orderId, paymentMethodId);
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error, { syncAuth: true })
+            throw this.#getNormalizedTransakError(error, { syncAuth: true })
                 .normalizedError;
         }
     }
@@ -2257,7 +3069,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:getTranslation', request);
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error).normalizedError;
+            throw this.#getNormalizedTransakError(error).normalizedError;
         }
     }
     /**
@@ -2271,7 +3083,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:getIdProofStatus', workFlowRunId);
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error, { syncAuth: true })
+            throw this.#getNormalizedTransakError(error, { syncAuth: true })
                 .normalizedError;
         }
     }
@@ -2286,7 +3098,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:cancelOrder', depositOrderId);
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error, { syncAuth: true })
+            throw this.#getNormalizedTransakError(error, { syncAuth: true })
                 .normalizedError;
         }
     }
@@ -2301,7 +3113,7 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:cancelAllActiveOrders');
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error, { syncAuth: true })
+            throw this.#getNormalizedTransakError(error, { syncAuth: true })
                 .normalizedError;
         }
     }
@@ -2315,479 +3127,9 @@ export class RampsController extends BaseController {
             return await this.messenger.call('TransakService:getActiveOrders');
         }
         catch (error) {
-            throw __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getNormalizedTransakError).call(this, error, { syncAuth: true })
+            throw this.#getNormalizedTransakError(error, { syncAuth: true })
                 .normalizedError;
         }
     }
 }
-_RampsController_requestCacheTTL = new WeakMap(), _RampsController_requestCacheMaxSize = new WeakMap(), _RampsController_pendingRequests = new WeakMap(), _RampsController_pendingResourceCount = new WeakMap(), _RampsController_pendingResourceGeneration = new WeakMap(), _RampsController_orderPollingMeta = new WeakMap(), _RampsController_orderPollingTimer = new WeakMap(), _RampsController_isPolling = new WeakMap(), _RampsController_initPromise = new WeakMap(), _RampsController_instances = new WeakSet(), _RampsController_clearPendingResourceCountForDependentResources = function _RampsController_clearPendingResourceCountForDependentResources() {
-    for (const resourceType of DEPENDENT_RESOURCE_KEYS) {
-        __classPrivateFieldGet(this, _RampsController_pendingResourceCount, "f").delete(resourceType);
-        const generation = __classPrivateFieldGet(this, _RampsController_pendingResourceGeneration, "f").get(resourceType) ?? 0;
-        __classPrivateFieldGet(this, _RampsController_pendingResourceGeneration, "f").set(resourceType, generation + 1);
-    }
-}, _RampsController_abortDependentRequests = function _RampsController_abortDependentRequests() {
-    for (const [cacheKey, pending] of __classPrivateFieldGet(this, _RampsController_pendingRequests, "f").entries()) {
-        if (pending.resourceType &&
-            DEPENDENT_RESOURCE_KEYS_SET.has(pending.resourceType)) {
-            pending.abortController.abort();
-            __classPrivateFieldGet(this, _RampsController_pendingRequests, "f").delete(cacheKey);
-            __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_removeRequestState).call(this, cacheKey);
-        }
-    }
-}, _RampsController_resolveAllProvidersFlag = function _RampsController_resolveAllProvidersFlag() {
-    try {
-        const remoteFeatureFlagState = this.messenger.call('RemoteFeatureFlagController:getState');
-        return {
-            enabled: isHeadlessAllProvidersEnabled(remoteFeatureFlagState),
-            allowlist: getHeadlessProviderAllowlist(remoteFeatureFlagState),
-        };
-    }
-    catch {
-        return { enabled: false };
-    }
-}, _RampsController_mutateRequests = function _RampsController_mutateRequests(fn) {
-    this.update((state) => {
-        const requests = state.requests;
-        fn(requests);
-    });
-}, _RampsController_removeRequestState = function _RampsController_removeRequestState(cacheKey) {
-    __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_mutateRequests).call(this, (requests) => {
-        delete requests[cacheKey];
-    });
-}, _RampsController_cleanupState = function _RampsController_cleanupState() {
-    __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_abortDependentRequests).call(this);
-    __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_clearPendingResourceCountForDependentResources).call(this);
-    this.update((state) => resetDependentResources(state, { clearUserRegionData: true }));
-}, _RampsController_requireRegion = function _RampsController_requireRegion() {
-    const regionCode = this.state.userRegion?.regionCode;
-    if (!regionCode) {
-        throw new Error('Region is required. Cannot proceed without valid region information.');
-    }
-    return regionCode;
-}, _RampsController_isRegionCurrent = function _RampsController_isRegionCurrent(normalizedRegion) {
-    const current = this.state.userRegion?.regionCode;
-    return current === undefined || current === normalizedRegion;
-}, _RampsController_isTokenCurrent = function _RampsController_isTokenCurrent(normalizedAssetId) {
-    const current = this.state.tokens.selected?.assetId ?? '';
-    return current === normalizedAssetId;
-}, _RampsController_isProviderCurrent = function _RampsController_isProviderCurrent(normalizedProviderId) {
-    const current = this.state.providers.selected?.id ?? '';
-    return current === normalizedProviderId;
-}, _RampsController_updateResourceField = function _RampsController_updateResourceField(resourceType, field, value) {
-    this.update((state) => {
-        const resource = getResourceState(state, resourceType);
-        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, errorInfo) {
-    this.update((state) => {
-        const resource = getResourceState(state, resourceType);
-        resource.error = errorInfo?.message ?? null;
-        resource.errorKey = errorInfo?.errorKey ?? null;
-    });
-}, _RampsController_updateRequestState = function _RampsController_updateRequestState(cacheKey, requestState) {
-    const maxSize = __classPrivateFieldGet(this, _RampsController_requestCacheMaxSize, "f");
-    const ttl = __classPrivateFieldGet(this, _RampsController_requestCacheTTL, "f");
-    __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_mutateRequests).call(this, (requests) => {
-        requests[cacheKey] = requestState;
-        const keys = Object.keys(requests);
-        for (const key of keys) {
-            const entry = requests[key];
-            if (entry?.status === RequestStatus.SUCCESS &&
-                isCacheExpired(entry, ttl)) {
-                delete requests[key];
-            }
-        }
-        const remainingKeys = Object.keys(requests);
-        if (remainingKeys.length > maxSize) {
-            const sortedKeys = remainingKeys.sort((a, b) => {
-                const aTime = requests[a]?.timestamp ?? 0;
-                const bTime = requests[b]?.timestamp ?? 0;
-                return aTime - bTime;
-            });
-            const entriesToRemove = remainingKeys.length - maxSize;
-            for (let i = 0; i < entriesToRemove; i++) {
-                const keyToRemove = sortedKeys[i];
-                if (keyToRemove) {
-                    delete requests[keyToRemove];
-                }
-            }
-        }
-    });
-}, _RampsController_runInit = async function _RampsController_runInit(options) {
-    // Force-refetch the catalog on startup so region preset amounts stay
-    // current, bypassing the in-session request cache. The catalog is not
-    // persisted, so a cold start always re-fetches it regardless.
-    await this.getCountries({ ...options, forceRefresh: true });
-    // Always prefer the user's persisted region. Geolocation is only used to
-    // seed the initial value; once the user (or a prior init) has set a region
-    // we must respect that choice — even on forceRefresh.
-    const persistedRegionCode = this.state.userRegion?.regionCode;
-    const regionCode = persistedRegionCode ??
-        (await this.messenger.call('RampsService:getGeolocation'));
-    if (!regionCode) {
-        throw new Error('Failed to fetch geolocation. Cannot initialize controller without valid region information.');
-    }
-    // For an already-persisted region, getCountries() has already re-synced it
-    // from the fresh catalog (see #syncUserRegionFromCountriesCatalog). Calling
-    // setUserRegion here would re-validate against that catalog and, if it is
-    // momentarily empty or no longer lists the region (e.g. a transient/partial
-    // catalog response or a region with no current provider coverage), throw and
-    // wipe the persisted region via #cleanupState. Preserve the existing region
-    // instead; only resolve a brand-new region (from geolocation) strictly.
-    if (persistedRegionCode) {
-        return;
-    }
-    await this.setUserRegion(regionCode, options);
-}, _RampsController_syncUserRegionFromCountriesCatalog = function _RampsController_syncUserRegionFromCountriesCatalog() {
-    const regionCode = this.state.userRegion?.regionCode;
-    if (!regionCode) {
-        return;
-    }
-    const countriesData = this.state.countries.data;
-    if (!countriesData.length) {
-        return;
-    }
-    const userRegion = findRegionFromCode(regionCode, countriesData);
-    if (!userRegion) {
-        return;
-    }
-    this.update((state) => {
-        state.userRegion = userRegion;
-    });
-}, _RampsController_pickWidenedQuote = function _RampsController_pickWidenedQuote(response, { amount, fiat, providers, allowlist, }) {
-    const providerByCode = new Map(providers.map((provider) => [provider.id, provider]));
-    const allowedProviderIds = allowlist && allowlist.length > 0
-        ? new Set(allowlist.map(normalizeHeadlessProviderId))
-        : undefined;
-    const isAllowedProvider = (quote) => !allowedProviderIds ||
-        allowedProviderIds.has(normalizeHeadlessProviderId(quote.provider));
-    const fitsProviderLimits = (quote) => {
-        const provider = providerByCode.get(quote.provider);
-        const limit = provider?.limits?.fiat?.[fiat]?.[quote.quote.paymentMethod];
-        if (!limit) {
-            // No published limits for this provider/payment method: treat as
-            // eligible and let the provider enforce limits at checkout.
-            return true;
-        }
-        return amount >= limit.minAmount && amount <= limit.maxAmount;
-    };
-    const candidates = response.success.filter((quote) => isAllowedProvider(quote) && fitsProviderLimits(quote));
-    if (candidates.length === 0) {
-        return undefined;
-    }
-    const candidateByCode = new Map(candidates.map((quote) => [quote.provider, quote]));
-    const pickBySortOrder = (sortBy) => {
-        const order = response.sorted.find((entry) => entry.sortBy === sortBy)?.ids;
-        if (!order) {
-            return undefined;
-        }
-        for (const providerId of order) {
-            const match = candidateByCode.get(providerId);
-            if (match) {
-                return match;
-            }
-        }
-        return undefined;
-    };
-    // Reliability first, then price, then the first surviving candidate.
-    return (pickBySortOrder('reliability') ??
-        pickBySortOrder('price') ??
-        candidates[0]);
-}, _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));
-    }
-    // Case-insensitive CAIP-19 matching is shared with headless-buy consumers
-    // via `getProvidersServingAsset`, so the controller and the UI region gate
-    // cannot disagree about which providers serve the asset.
-    const supporting = getProvidersServingAsset(providers, assetId);
-    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_resolveProviderIdsForPaymentMethods = 
-/**
- * Resolves provider IDs that should contribute payment methods for a
- * quoting context. Mirrors {@link getQuotes} provider-set selection, with
- * one intentional difference on the widened path: when the all-providers
- * flag allowlist is non-empty, returns supporting providers intersected
- * with that allowlist (pick survivors for the picker). Does not mutate
- * state.
- *
- * @param options - Resolution inputs aligned with `getQuotes`.
- * @param options.assetId - CAIP-19 asset type identifier to resolve for.
- * @param options.region - Region to resolve providers for.
- * @param options.providers - Explicit provider IDs, when provided.
- * @param options.autoSelectProvider - Resolve providers like `getQuotes`.
- * @param options.preferredProviderIds - Preferred provider IDs in order.
- * @param options.restrictToKnownOrNativeProviders - Headless gating.
- * @returns Provider IDs for this request only.
- */
-async function _RampsController_resolveProviderIdsForPaymentMethods({ assetId, region, providers, autoSelectProvider, preferredProviderIds, restrictToKnownOrNativeProviders, }) {
-    const wantsAutoSelection = !providers &&
-        (autoSelectProvider === true ||
-            restrictToKnownOrNativeProviders === true);
-    const { enabled: allProvidersEnabled, allowlist: providerAllowlist } = wantsAutoSelection
-        ? __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_resolveAllProvidersFlag).call(this)
-        : { enabled: false, allowlist: undefined };
-    const widenToAllProviders = wantsAutoSelection && allProvidersEnabled;
-    if (providers) {
-        return restrictToKnownOrNativeProviders
-            ? __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_filterProviderIdsBySupport).call(this, {
-                providerIds: providers,
-                assetId,
-                region,
-            })
-            : providers;
-    }
-    if (widenToAllProviders) {
-        const { supporting } = await __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_getSupportingProvidersForRegion).call(this, {
-            assetId,
-            region,
-        });
-        if (providerAllowlist && providerAllowlist.length > 0) {
-            const allowedProviderIds = new Set(providerAllowlist.map(normalizeHeadlessProviderId));
-            return supporting
-                .filter((provider) => allowedProviderIds.has(normalizeHeadlessProviderId(provider.id)))
-                .map((provider) => provider.id);
-        }
-        return supporting.map((provider) => provider.id);
-    }
-    if (autoSelectProvider || restrictToKnownOrNativeProviders) {
-        return __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_resolveProviderIdsForQuote).call(this, {
-            assetId,
-            region,
-            preferredProviderIds,
-            restrictToKnownOrNative: restrictToKnownOrNativeProviders,
-        });
-    }
-    const selectedId = this.state.providers.selected?.id;
-    return selectedId ? [selectedId] : [];
-}, _RampsController_getPreferredProviderIdsFromOrders = function _RampsController_getPreferredProviderIdsFromOrders() {
-    const orderedIds = [];
-    const completedOrders = this.state.orders
-        .filter((order) => order.status === 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_applyAutorampRemoteSnapshot = function _RampsController_applyAutorampRemoteSnapshot(remote, { allowInsert = true } = {}) {
-    const local = this.state.autoramps.find((autoramp) => autoramp.id === remote.id) ??
-        null;
-    if (local === null && !allowInsert) {
-        return applyAutorampRemoteStatus(null, remote).account;
-    }
-    const result = applyAutorampRemoteStatus(local, remote);
-    this.update((state) => {
-        const idx = state.autoramps.findIndex((autoramp) => autoramp.id === result.account.id);
-        if (idx === -1) {
-            state.autoramps.push(result.account);
-        }
-        else {
-            state.autoramps[idx] = result.account;
-        }
-    });
-    if (result.statusChanged) {
-        this.messenger.publish('RampsController:autorampStatusChanged', {
-            autoramp: result.account,
-            previousStatus: result.previousStatus,
-            shouldNotify: result.shouldNotify,
-        });
-    }
-    return (this.state.autoramps.find((autoramp) => autoramp.id === result.account.id) ?? result.account);
-}, _RampsController_refreshOrder = 
-/**
- * Refreshes a single order via the V2 API and updates it in state.
- * Publishes orderStatusChanged if the status transitioned.
- *
- * @param order - The order to refresh (needs provider and providerOrderId).
- */
-async function _RampsController_refreshOrder(order) {
-    const providerCode = order.provider?.id ?? '';
-    if (!providerCode || !order.providerOrderId || !order.walletAddress) {
-        return;
-    }
-    const previousStatus = order.status;
-    try {
-        const updatedOrder = await this.getOrder(providerCode, order.providerOrderId, order.walletAddress);
-        const meta = __classPrivateFieldGet(this, _RampsController_orderPollingMeta, "f").get(order.providerOrderId) ?? {
-            lastTimeFetched: 0,
-            errorCount: 0,
-        };
-        if (updatedOrder.status === RampsOrderStatus.Unknown) {
-            meta.errorCount = Math.min(meta.errorCount + 1, MAX_ERROR_COUNT);
-        }
-        else {
-            meta.errorCount = 0;
-        }
-        meta.lastTimeFetched = Date.now();
-        __classPrivateFieldGet(this, _RampsController_orderPollingMeta, "f").set(order.providerOrderId, meta);
-        if (previousStatus !== updatedOrder.status &&
-            previousStatus !== undefined) {
-            this.messenger.publish('RampsController:orderStatusChanged', {
-                order: updatedOrder,
-                previousStatus,
-            });
-        }
-        if (TERMINAL_ORDER_STATUSES.has(updatedOrder.status)) {
-            __classPrivateFieldGet(this, _RampsController_orderPollingMeta, "f").delete(order.providerOrderId);
-        }
-    }
-    catch {
-        const meta = __classPrivateFieldGet(this, _RampsController_orderPollingMeta, "f").get(order.providerOrderId) ?? {
-            lastTimeFetched: 0,
-            errorCount: 0,
-        };
-        meta.errorCount = Math.min(meta.errorCount + 1, MAX_ERROR_COUNT);
-        meta.lastTimeFetched = Date.now();
-        __classPrivateFieldGet(this, _RampsController_orderPollingMeta, "f").set(order.providerOrderId, meta);
-    }
-}, _RampsController_pollPendingOrders = async function _RampsController_pollPendingOrders() {
-    if (__classPrivateFieldGet(this, _RampsController_isPolling, "f")) {
-        return;
-    }
-    __classPrivateFieldSet(this, _RampsController_isPolling, true, "f");
-    try {
-        const pendingOrders = this.state.orders.filter((order) => PENDING_ORDER_STATUSES.has(order.status));
-        const now = Date.now();
-        await Promise.allSettled(pendingOrders.map(async (order) => {
-            const meta = __classPrivateFieldGet(this, _RampsController_orderPollingMeta, "f").get(order.providerOrderId);
-            if (meta) {
-                const backoffMs = meta.errorCount > 0
-                    ? Math.min(DEFAULT_POLLING_INTERVAL_MS *
-                        Math.pow(2, meta.errorCount - 1), 5 * 60 * 1000)
-                    : 0;
-                const pollingMinMs = (order.pollingSecondsMinimum ?? 0) * 1000;
-                const minWait = Math.max(backoffMs, pollingMinMs);
-                if (now - meta.lastTimeFetched < minWait) {
-                    return;
-                }
-            }
-            await __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_refreshOrder).call(this, order);
-        }));
-    }
-    finally {
-        __classPrivateFieldSet(this, _RampsController_isPolling, false, "f");
-    }
-}, _RampsController_syncTransakAuthOnError = function _RampsController_syncTransakAuthOnError(error) {
-    if (hasHttpStatus(error) && error.httpStatus === 401) {
-        this.transakSetAuthenticated(false);
-    }
-}, _RampsController_getNormalizedTransakError = function _RampsController_getNormalizedTransakError(error, options = {}) {
-    if (options.syncAuth) {
-        __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_syncTransakAuthOnError).call(this, error);
-    }
-    return getNormalizedRampsError(error);
-};
-//# sourceMappingURL=RampsController.mjs.map
+//# sourceMappingURL=RampsController.js.map