@metamask/ramps-controller 20.2.0 → 21.0.0

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

@@ -1,24 +1,16 @@
-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_refreshOrder, _RampsController_pollPendingOrders, _RampsController_syncTransakAuthOnError, _RampsController_getNormalizedTransakError;
-import { BaseController } from "@metamask/base-controller";
-import { BrokenCircuitError } from "@metamask/controller-utils";
-import { getHeadlessProviderAllowlist, isHeadlessAllProvidersEnabled, normalizeHeadlessProviderId } from "./featureFlags.mjs";
-import { PENDING_ORDER_STATUSES, TERMINAL_ORDER_STATUSES } from "./orderStatus.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 { 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 { 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
@@ -67,7 +59,36 @@ export const RAMPS_CONTROLLER_REQUIRED_SERVICE_ACTIONS = [
     'TransakService:cancelOrder',
     'TransakService:cancelAllActiveOrders',
     'TransakService:getActiveOrders',
+    'NeoBankService:getAutoramp',
+    'NeoBankService:createAutoramp',
+    'NeoBankService:getCustomerByExternalId',
+    'NeoBankService:getWalletRegistrationStatus',
+    'NeoBankService:registerSelfHostedWallet',
 ];
+/**
+ * Every external controller action RampsController calls via the messenger,
+ * which hosts must delegate from the root messenger.
+ * `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.
+ */
+export const RAMPS_CONTROLLER_REQUIRED_CONTROLLER_ACTIONS = [
+    'AuthenticationController:getSessionProfile',
+    'KeyringController:signPersonalMessage',
+    'RemoteFeatureFlagController:getState',
+];
+/**
+ * Distinguishes an already-materialized {@link AutorampAccount} from the
+ * create-fields shape accepted by {@link RampsController.addAutoramp}.
+ *
+ * @param value - Full account or create fields.
+ * @returns Whether the value already carries the derived account fields.
+ */
+function isFullAutorampAccount(value) {
+    return (typeof value.updatedAt === 'number' &&
+        value.lastSeenStatus !== undefined);
+}
 /**
  * Default TTL for quotes requests (15 seconds).
  * Quotes are time-sensitive and should have a shorter cache duration.
@@ -179,6 +200,12 @@ const rampsControllerMetadata = {
         includeInStateLogs: true,
         usedInUi: true,
     },
+    autoramps: {
+        persist: true,
+        includeInDebugSnapshot: true,
+        includeInStateLogs: true,
+        usedInUi: true,
+    },
     providerAutoSelected: {
         persist: true,
         includeInDebugSnapshot: true,
@@ -228,6 +255,7 @@ export function getDefaultRampsControllerState() {
             },
         },
         orders: [],
+        autoramps: [],
         providerAutoSelected: false,
     };
 }
@@ -352,7 +380,7 @@ export function getInternalOrderCode(orderOrId) {
     return providerOrderId;
 }
 // === 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 = [
@@ -373,6 +401,14 @@ const MESSENGER_EXPOSED_METHODS = [
     'getQuotes',
     'addOrder',
     'removeOrder',
+    'addAutoramp',
+    'createAutoramp',
+    'removeAutoramp',
+    'registerMoneyAccountWallet',
+    'markAutorampAsNotified',
+    'applyAutorampStatusFromPush',
+    'refreshAutoramp',
+    'refreshAutoramps',
     'startOrderPolling',
     'stopOrderPolling',
     'getBuyWidgetData',
@@ -428,6 +464,33 @@ 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;
+    /**
+     * 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;
     /**
      * Clears the pending resource count map. Used only in tests to exercise the
      * defensive path when get() returns undefined in the finally block.
@@ -435,7 +498,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}.
@@ -459,38 +539,39 @@ 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.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.
@@ -517,11 +598,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;
         }
@@ -539,17 +620,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
@@ -559,11 +640,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;
@@ -573,38 +654,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,
@@ -618,15 +699,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.
      *
@@ -636,6 +794,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.
@@ -649,12 +843,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) ||
@@ -665,7 +859,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) {
@@ -676,7 +870,7 @@ export class RampsController extends BaseController {
             return userRegion;
         }
         catch (error) {
-            __classPrivateFieldGet(this, _RampsController_instances, "m", _RampsController_cleanupState).call(this);
+            this.#cleanupState();
             throw error;
         }
     }
@@ -701,7 +895,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') {
@@ -781,21 +975,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.
@@ -812,7 +1053,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;
     }
     /**
@@ -826,7 +1067,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,
@@ -840,7 +1081,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;
@@ -865,7 +1106,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.');
@@ -891,7 +1132,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,
@@ -908,7 +1149,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) => {
@@ -930,7 +1171,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();
@@ -949,9 +1190,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;
             },
         });
@@ -1014,7 +1255,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 === '') {
@@ -1025,7 +1266,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,
@@ -1177,7 +1418,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);
@@ -1202,14 +1443,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,
@@ -1220,7 +1461,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,
             });
@@ -1232,7 +1473,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,
@@ -1315,7 +1556,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,
@@ -1339,6 +1580,261 @@ 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.
@@ -1376,7 +1872,387 @@ export class RampsController extends BaseController {
         this.update((state) => {
             state.orders = state.orders.filter((order) => order.providerOrderId !== providerOrderId);
         });
-        __classPrivateFieldGet(this, _RampsController_orderPollingMeta, "f").delete(providerOrderId);
+        this.#orderPollingMeta.delete(providerOrderId);
+    }
+    /**
+     * Adds or updates a local autoramp last-seen cursor (e.g. after create).
+     *
+     * @param accountOrInput - Full account or create fields.
+     * @returns The upserted {@link AutorampAccount}.
+     */
+    addAutoramp(accountOrInput) {
+        const account = isFullAutorampAccount(accountOrInput)
+            ? accountOrInput
+            : createAutorampAccount(accountOrInput);
+        this.update((state) => {
+            const idx = state.autoramps.findIndex((existing) => existing.id === account.id);
+            if (idx === -1) {
+                state.autoramps.push(account);
+            }
+            else {
+                state.autoramps[idx] = {
+                    ...state.autoramps[idx],
+                    ...account,
+                };
+            }
+        });
+        return (this.state.autoramps.find((existing) => existing.id === account.id) ??
+            account);
+    }
+    /**
+     * Creates an autoramp via the neo-bank proxy and applies the returned
+     * snapshot as the local last-seen cursor.
+     *
+     * The vendor `customer_id` is resolved via
+     * {@link RampsController.resolveAutorampCustomerId} and injected into the
+     * request (any caller-supplied `customer_id` is overwritten).
+     *
+     * @param request - CreateAutoramp payload.
+     * @param options - Optional idempotency key forwarded to the proxy.
+     * @param options.idempotencyKey - Value sent as `Idempotency-Key`.
+     * @returns The created/updated local {@link AutorampAccount}.
+     */
+    async createAutoramp(request, options = {}) {
+        const customerId = await this.resolveAutorampCustomerId();
+        const body = { ...request, customer_id: customerId };
+        const remote = await this.messenger.call('NeoBankService:createAutoramp', body, options);
+        return this.#applyAutorampRemoteSnapshot(remote);
+    }
+    /**
+     * Resolves the vendor `customer_id` for autoramp / Money Account operations.
+     *
+     * Maps the wallet's Profile Sync id (the partner `external_id`) to the
+     * vendor customer via `GET /neobank/customers/{external_id}/external`.
+     *
+     * @returns The vendor customer id.
+     */
+    async resolveAutorampCustomerId() {
+        const profile = await this.messenger.call('AuthenticationController:getSessionProfile');
+        const canonical = profile?.canonicalProfileId;
+        const externalId = typeof canonical === 'string' && canonical.length > 0
+            ? canonical
+            : profile?.profileId;
+        if (typeof externalId !== 'string' || externalId.length === 0) {
+            throw new Error('Cannot resolve MoonPay customer id: wallet is not signed in to Profile Sync.');
+        }
+        const customer = await this.messenger.call('NeoBankService:getCustomerByExternalId', externalId);
+        const customerId = customer &&
+            typeof customer === 'object' &&
+            typeof customer.id === 'string'
+            ? customer.id
+            : null;
+        if (!customerId) {
+            throw new Error(`Cannot resolve MoonPay customer id: no MoonPay customer is mapped to external id "${externalId}".`);
+        }
+        return customerId;
+    }
+    /**
+     * Registers a Money Account wallet with MoonPay Iron via neobank-proxy.
+     *
+     * @param params - Money Account wallet registration parameters.
+     * @param params.address - Monad Money Account address.
+     * @returns The registration state, or `{ type: 'lookupUnavailable' }` when
+     * the address-list lookup fails (never treated as unregistered).
+     */
+    async registerMoneyAccountWallet({ address, }) {
+        let machine = transitionWalletRegistration(createInitialWalletRegistrationState(), { type: 'START' });
+        const toExistingResult = (status) => {
+            if (status.type === 'active') {
+                return { type: 'alreadyRegistered', registration: status.registration };
+            }
+            if (status.type === 'disabled') {
+                return {
+                    type: 'registeredDisabled',
+                    registration: status.registration,
+                };
+            }
+            return undefined;
+        };
+        const customerId = await this.resolveAutorampCustomerId();
+        const toLookupUnavailableResult = (error) => {
+            machine = transitionWalletRegistration(machine, {
+                type: 'LOOKUP_FAILED',
+            });
+            return {
+                type: 'lookupUnavailable',
+                error: error instanceof WalletRegistrationError
+                    ? error
+                    : new WalletRegistrationError('lookupUnavailable', {
+                        message: 'self-hosted address lookup failed',
+                        body: error instanceof Error ? error.message : undefined,
+                    }),
+            };
+        };
+        const lookup = async () => {
+            try {
+                return await this.messenger.call('NeoBankService:getWalletRegistrationStatus', { customerId, address });
+            }
+            catch (error) {
+                return toLookupUnavailableResult(error);
+            }
+        };
+        const applyLookup = (status) => {
+            let eventType = 'LOOKUP_ABSENT';
+            if (status.type === 'active') {
+                eventType = 'LOOKUP_ACTIVE';
+            }
+            else if (status.type === 'disabled') {
+                eventType = 'LOOKUP_DISABLED';
+            }
+            machine = transitionWalletRegistration(machine, {
+                type: eventType,
+            });
+            return toExistingResult(status);
+        };
+        const resolveLookup = async () => {
+            const status = await lookup();
+            if (status.type === 'lookupUnavailable') {
+                return status;
+            }
+            return applyLookup(status);
+        };
+        const existingResult = await resolveLookup();
+        if (existingResult) {
+            return existingResult;
+        }
+        let idempotencyKey = createIdempotencyKey();
+        let lastMessage;
+        while (true) {
+            const message = buildOwnershipMessage({
+                address,
+                customerId,
+                now: new Date(),
+            });
+            if (lastMessage !== undefined && message !== lastMessage) {
+                idempotencyKey = createIdempotencyKey();
+            }
+            lastMessage = message;
+            let signature;
+            try {
+                signature = await this.messenger.call('KeyringController:signPersonalMessage', { data: message, from: address });
+                machine = transitionWalletRegistration(machine, { type: 'SIGN_OK' });
+            }
+            catch (error) {
+                machine = transitionWalletRegistration(machine, {
+                    type: 'SIGN_FAILED',
+                    retryable: false,
+                });
+                throw error;
+            }
+            try {
+                const result = await this.messenger.call('NeoBankService:registerSelfHostedWallet', {
+                    address,
+                    customerId,
+                    message,
+                    signature,
+                    idempotencyKey,
+                });
+                machine = transitionWalletRegistration(machine, { type: 'SUBMIT_OK' });
+                return result;
+            }
+            catch (error) {
+                if (!(error instanceof WalletRegistrationError)) {
+                    machine = transitionWalletRegistration(machine, {
+                        type: 'SUBMIT_TERMINAL',
+                    });
+                    throw error;
+                }
+                if (error.kind === 'conflict') {
+                    machine = transitionWalletRegistration(machine, {
+                        type: 'SUBMIT_CONFLICT',
+                    });
+                }
+                else if (error.kind === 'transient') {
+                    machine = transitionWalletRegistration(machine, {
+                        type: 'SUBMIT_TRANSIENT',
+                    });
+                }
+                else if (error.kind === 'validation') {
+                    machine = transitionWalletRegistration(machine, {
+                        type: 'SUBMIT_VALIDATION',
+                        utcRollover: buildOwnershipMessage({
+                            address,
+                            customerId,
+                            now: new Date(),
+                        }) !== message,
+                    });
+                }
+                else if (error.kind === 'rateLimited') {
+                    machine = transitionWalletRegistration(machine, {
+                        type: 'SUBMIT_RATE_LIMITED',
+                    });
+                }
+                else {
+                    machine = transitionWalletRegistration(machine, {
+                        type: 'SUBMIT_TERMINAL',
+                    });
+                }
+                if (machine.status === 'disambiguate409' ||
+                    machine.status === 'checkThenRetry') {
+                    const reconciledResult = await resolveLookup();
+                    if (reconciledResult) {
+                        return reconciledResult;
+                    }
+                }
+                if (machine.status !== 'signing') {
+                    throw error;
+                }
+            }
+        }
+    }
+    /**
+     * Removes a local autoramp last-seen cursor by id.
+     *
+     * @param autorampId - MoonPay autoramp id.
+     */
+    removeAutoramp(autorampId) {
+        this.update((state) => {
+            state.autoramps = state.autoramps.filter((autoramp) => autoramp.id !== autorampId);
+        });
+    }
+    /**
+     * Marks that the UI has already notified for the autoramp's current status.
+     *
+     * @param autorampId - MoonPay autoramp id.
+     */
+    markAutorampAsNotified(autorampId) {
+        const existing = this.state.autoramps.find((autoramp) => autoramp.id === autorampId);
+        if (!existing) {
+            return;
+        }
+        const notified = markAutorampNotified(existing);
+        this.update((state) => {
+            const idx = state.autoramps.findIndex((autoramp) => autoramp.id === autorampId);
+            if (idx !== -1) {
+                state.autoramps[idx] = notified;
+            }
+        });
+    }
+    /**
+     * Applies a remote autoramp snapshot from a websocket / webhook push.
+     *
+     * @param remote - Remote autoramp snapshot.
+     * @returns The updated local account.
+     */
+    applyAutorampStatusFromPush(remote) {
+        return this.#applyAutorampRemoteSnapshot(remote);
+    }
+    /**
+     * Fetches one autoramp from the neo-bank proxy and applies it to the
+     * last-seen cursor. Does not recreate a cursor that was removed while the
+     * request was in flight.
+     *
+     * @param autorampId - MoonPay autoramp id.
+     * @returns The updated local account, or an unpersisted snapshot if the
+     * cursor was removed during the fetch.
+     */
+    async refreshAutoramp(autorampId) {
+        const remote = await this.messenger.call('NeoBankService:getAutoramp', autorampId);
+        return this.#applyAutorampRemoteSnapshot(remote, { allowInsert: false });
+    }
+    /**
+     * Refreshes all known local autoramps from MoonPay.
+     * Intended for app resume / unlock catch-up when webhooks were missed.
+     *
+     * @returns Updated autoramp accounts (failed fetches are skipped).
+     */
+    async refreshAutoramps() {
+        const ids = this.state.autoramps.map((autoramp) => autoramp.id);
+        const updated = [];
+        for (const id of ids) {
+            try {
+                const account = await this.refreshAutoramp(id);
+                if (this.state.autoramps.some((autoramp) => autoramp.id === account.id)) {
+                    updated.push(account);
+                }
+            }
+            catch {
+                // Keep local cursor for this id; continue remaining refreshes.
+            }
+        }
+        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.
@@ -1384,21 +2260,49 @@ export class RampsController extends BaseController {
      * 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;
         }
     }
     /**
@@ -1529,6 +2433,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.
      *
@@ -1584,7 +2512,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;
         }
     }
     /**
@@ -1603,7 +2531,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;
         }
     }
     /**
@@ -1617,7 +2545,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();
@@ -1647,7 +2575,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) => {
@@ -1684,7 +2612,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;
@@ -1715,7 +2643,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) => {
@@ -1738,7 +2666,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;
         }
     }
@@ -1756,7 +2684,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;
         }
     }
@@ -1773,7 +2701,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;
         }
     }
     /**
@@ -1789,7 +2717,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;
         }
     }
@@ -1803,7 +2731,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;
         }
     }
@@ -1834,7 +2762,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;
         }
     }
@@ -1849,7 +2777,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;
         }
     }
@@ -1864,7 +2792,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;
         }
     }
@@ -1880,7 +2808,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;
         }
     }
@@ -1896,7 +2824,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;
         }
     }
@@ -1911,7 +2839,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;
         }
     }
     /**
@@ -1925,7 +2853,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;
         }
     }
@@ -1940,7 +2868,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;
         }
     }
@@ -1955,7 +2883,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;
         }
     }
@@ -1969,455 +2897,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_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