@metamask-previews/perps-controller 0.0.0-preview-685dbf46b → 1.0.0-preview-bc00f2c

package/dist/PerpsController.mjs

@@ -1,83 +1,3094 @@
+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 _PerpsController_instances, _a, _PerpsController_initializationPromise, _PerpsController_isReinitializing, _PerpsController_blockedRegionListVersion, _PerpsController_hip3Enabled, _PerpsController_hip3AllowlistMarkets, _PerpsController_hip3BlocklistMarkets, _PerpsController_hip3ConfigSource, _PerpsController_isMYXProviderEnabled, _PerpsController_standaloneProvider, _PerpsController_standaloneProviderIsTestnet, _PerpsController_standaloneProviderHip3Version, _PerpsController_options, _PerpsController_tradingService, _PerpsController_marketDataService, _PerpsController_accountService, _PerpsController_eligibilityService, _PerpsController_dataLakeService, _PerpsController_depositService, _PerpsController_featureFlagConfigurationService, _PerpsController_rewardsIntegrationService, _PerpsController_logError, _PerpsController_debugLog, _PerpsController_getOrCreateStandaloneProvider, _PerpsController_cleanupStandaloneProvider, _PerpsController_getMetrics, _PerpsController_findNetworkClientIdForChain, _PerpsController_submitTransaction, _PerpsController_migrateRequestsIfNeeded, _PerpsController_withStreamPause, _PerpsController_performInitialization, _PerpsController_getErrorContext, _PerpsController_getControllerState, _PerpsController_createServiceContext, _PerpsController_ensureTradingServiceDeps, _PerpsController_preloadWatchedPaths, _PerpsController_preloadTimer, _PerpsController_isPreloading, _PerpsController_isPreloadingUserData, _PerpsController_preloadStateUnsubscribe, _PerpsController_accountChangeUnsubscribe, _PerpsController_previousIsTestnet, _PerpsController_previousHip3ConfigVersion, _PerpsController_preloadRefreshMs, _PerpsController_preloadGuardMs, _PerpsController_performMarketDataPreload, _PerpsController_performUserDataPreload;
 import { BaseController } from "@metamask/base-controller";
+import { ORIGIN_METAMASK } from "@metamask/controller-utils";
+import { v4 as uuidv4 } from "uuid";
+import { CandlePeriod } from "./constants/chartConfig.mjs";
+import { PERPS_EVENT_PROPERTY, PERPS_EVENT_VALUE } from "./constants/eventNames.mjs";
+import { USDC_SYMBOL } from "./constants/hyperLiquidConfig.mjs";
+import { PerpsMeasurementName } from "./constants/performanceMetrics.mjs";
+import { PERPS_CONSTANTS, MARKET_SORTING_CONFIG, PROVIDER_CONFIG } from "./constants/perpsConfig.mjs";
+import { PERPS_ERROR_CODES } from "./perpsErrorCodes.mjs";
+import { AggregatedPerpsProvider } from "./providers/AggregatedPerpsProvider.mjs";
+import { HyperLiquidProvider } from "./providers/HyperLiquidProvider.mjs";
+import { MYXProvider } from "./providers/MYXProvider.mjs";
+import { AccountService } from "./services/AccountService.mjs";
+import { DataLakeService } from "./services/DataLakeService.mjs";
+import { DepositService } from "./services/DepositService.mjs";
+import { EligibilityService } from "./services/EligibilityService.mjs";
+import { FeatureFlagConfigurationService } from "./services/FeatureFlagConfigurationService.mjs";
+import { MarketDataService } from "./services/MarketDataService.mjs";
+import { RewardsIntegrationService } from "./services/RewardsIntegrationService.mjs";
+import { TradingService } from "./services/TradingService.mjs";
+// PerpsStreamChannelKey removed: using string for channel keys (PerpsStreamManager.pauseChannel takes string)
+import { WebSocketConnectionState, PerpsAnalyticsEvent, PerpsTraceNames, PerpsTraceOperations, isVersionGatedFeatureFlag } from "./types/index.mjs";
+import { getSelectedEvmAccount } from "./utils/accountUtils.mjs";
+import { ensureError } from "./utils/errorUtils.mjs";
+import { wait } from "./utils/wait.mjs";
+// Re-export error codes from separate file to avoid circular dependencies
+export { PERPS_ERROR_CODES } from "./perpsErrorCodes.mjs";
 /**
- * The name of the {@link PerpsController}, used to namespace the
- * controller's actions and events and to namespace the controller's state data
- * when composed with other controllers.
+ * Initialization state enum for state machine tracking
  */
-export const controllerName = 'PerpsController';
+export var InitializationState;
+(function (InitializationState) {
+    InitializationState["Uninitialized"] = "uninitialized";
+    InitializationState["Initializing"] = "initializing";
+    InitializationState["Initialized"] = "initialized";
+    InitializationState["Failed"] = "failed";
+})(InitializationState || (InitializationState = {}));
 /**
- * The metadata for each property in {@link PerpsControllerState}.
+ * Get default PerpsController state
+ *
+ * To change the active provider, modify the `activeProvider` value below:
+ * - 'hyperliquid': HyperLiquid provider (default, production)
+ * - 'aggregated': Multi-provider aggregation mode
+ * - 'myx': MYX provider (future implementation)
+ *
+ * @returns The default perps controller state.
+ */
+export const getDefaultPerpsControllerState = () => ({
+    activeProvider: 'hyperliquid',
+    isTestnet: false, // Default to mainnet
+    initializationState: InitializationState.Uninitialized,
+    initializationError: null,
+    initializationAttempts: 0,
+    accountState: null,
+    perpsBalances: {},
+    depositInProgress: false,
+    lastDepositResult: null,
+    withdrawInProgress: false,
+    lastDepositTransactionId: null,
+    lastWithdrawResult: null,
+    withdrawalRequests: [],
+    withdrawalProgress: {
+        progress: 0,
+        lastUpdated: 0,
+        activeWithdrawalId: null,
+    },
+    depositRequests: [],
+    lastError: null,
+    lastUpdateTimestamp: 0,
+    isEligible: false,
+    isFirstTimeUser: {
+        testnet: true,
+        mainnet: true,
+    },
+    hasPlacedFirstOrder: {
+        testnet: false,
+        mainnet: false,
+    },
+    watchlistMarkets: {
+        testnet: [],
+        mainnet: [],
+    },
+    tradeConfigurations: {
+        testnet: {},
+        mainnet: {},
+    },
+    marketFilterPreferences: {
+        optionId: MARKET_SORTING_CONFIG.DefaultSortOptionId,
+        direction: MARKET_SORTING_CONFIG.DefaultDirection,
+    },
+    hip3ConfigVersion: 0,
+    selectedPaymentToken: null,
+    cachedMarketData: null,
+    cachedMarketDataTimestamp: 0,
+    cachedPositions: null,
+    cachedOrders: null,
+    cachedAccountState: null,
+    cachedUserDataTimestamp: 0,
+    cachedUserDataAddress: null,
+});
+/**
+ * State metadata for the PerpsController
  */
-const perpsControllerMetadata = {};
+const metadata = {
+    accountState: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    perpsBalances: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    isTestnet: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    activeProvider: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    initializationState: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    initializationError: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    initializationAttempts: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: false,
+    },
+    depositInProgress: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    lastDepositTransactionId: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    lastDepositResult: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    withdrawInProgress: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    lastWithdrawResult: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    withdrawalRequests: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    withdrawalProgress: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    depositRequests: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    lastError: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: false,
+    },
+    lastUpdateTimestamp: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: false,
+    },
+    isEligible: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    isFirstTimeUser: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    hasPlacedFirstOrder: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    watchlistMarkets: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    tradeConfigurations: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    marketFilterPreferences: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    hip3ConfigVersion: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: false,
+    },
+    selectedPaymentToken: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    cachedMarketData: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    cachedMarketDataTimestamp: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: false,
+    },
+    cachedPositions: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    cachedOrders: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    cachedAccountState: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: true,
+    },
+    cachedUserDataTimestamp: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: false,
+    },
+    cachedUserDataAddress: {
+        includeInStateLogs: false,
+        persist: false,
+        includeInDebugSnapshot: false,
+        usedInUi: false,
+    },
+};
+const MESSENGER_EXPOSED_METHODS = [
+    'placeOrder',
+    'editOrder',
+    'cancelOrder',
+    'cancelOrders',
+    'closePosition',
+    'closePositions',
+    'withdraw',
+    'getPositions',
+    'getOrderFills',
+    'getOrders',
+    'getOpenOrders',
+    'getFunding',
+    'getAccountState',
+    'getMarkets',
+    'refreshEligibility',
+    'toggleTestnet',
+    'disconnect',
+    'calculateFees',
+    'markTutorialCompleted',
+    'markFirstOrderCompleted',
+    'getHistoricalPortfolio',
+    'resetFirstTimeUserState',
+    'clearPendingTransactionRequests',
+    'saveTradeConfiguration',
+    'getTradeConfiguration',
+    'saveMarketFilterPreferences',
+    'getMarketFilterPreferences',
+    'savePendingTradeConfiguration',
+    'getPendingTradeConfiguration',
+    'clearPendingTradeConfiguration',
+    'getOrderBookGrouping',
+    'saveOrderBookGrouping',
+    'setSelectedPaymentToken',
+    'resetSelectedPaymentToken',
+];
 /**
- * Constructs the default {@link PerpsController} state. This allows
- * consumers to provide a partial state object when initializing the controller
- * and also helps in constructing complete state objects for this controller in
- * tests.
+ * PerpsController - Protocol-agnostic perpetuals trading controller
  *
- * @returns The default {@link PerpsController} state.
+ * Provides a unified interface for perpetual futures trading across multiple protocols.
+ * Features dual data flow architecture:
+ * - Trading actions use Redux for persistence and optimistic updates
+ * - Live data uses direct callbacks for maximum performance
  */
-export function getDefaultPerpsControllerState() {
-    return {};
+export class PerpsController extends BaseController {
+    constructor({ messenger, state = {}, clientConfig = {}, infrastructure, }) {
+        super({
+            name: 'PerpsController',
+            metadata,
+            messenger,
+            state: { ...getDefaultPerpsControllerState(), ...state },
+        });
+        _PerpsController_instances.add(this);
+        this.isInitialized = false;
+        _PerpsController_initializationPromise.set(this, null);
+        _PerpsController_isReinitializing.set(this, false);
+        this.blockedRegionList = {
+            list: [],
+            source: 'fallback',
+        };
+        /**
+         * Version counter for blocked region list.
+         * Used to prevent race conditions where stale eligibility checks
+         * (started with fallback config) overwrite results from newer checks
+         * (started with remote config).
+         */
+        _PerpsController_blockedRegionListVersion.set(this, 0);
+        // Store HIP-3 configuration (mutable for runtime updates from remote flags)
+        _PerpsController_hip3Enabled.set(this, void 0);
+        _PerpsController_hip3AllowlistMarkets.set(this, void 0);
+        _PerpsController_hip3BlocklistMarkets.set(this, void 0);
+        _PerpsController_hip3ConfigSource.set(this, 'fallback');
+        /**
+         * Active provider instance for routing operations.
+         * When activeProvider is 'hyperliquid' or 'myx': points to specific provider directly
+         * When activeProvider is 'aggregated': points to AggregatedPerpsProvider wrapper
+         */
+        this.activeProviderInstance = null;
+        /**
+         * Cached standalone provider for pre-initialization discovery queries.
+         * Avoids creating a new HyperLiquidProvider (and potentially leaking WebSocket
+         * connections) on every standalone call from the preload cycle.
+         */
+        _PerpsController_standaloneProvider.set(this, null);
+        _PerpsController_standaloneProviderIsTestnet.set(this, null);
+        _PerpsController_standaloneProviderHip3Version.set(this, null);
+        // Store options for dependency injection (allows core package to inject platform-specific services)
+        _PerpsController_options.set(this, void 0);
+        // Service instances (instantiated with platform dependencies)
+        _PerpsController_tradingService.set(this, void 0);
+        _PerpsController_marketDataService.set(this, void 0);
+        _PerpsController_accountService.set(this, void 0);
+        _PerpsController_eligibilityService.set(this, void 0);
+        _PerpsController_dataLakeService.set(this, void 0);
+        _PerpsController_depositService.set(this, void 0);
+        _PerpsController_featureFlagConfigurationService.set(this, void 0);
+        _PerpsController_rewardsIntegrationService.set(this, void 0);
+        _PerpsController_preloadTimer.set(this, null);
+        _PerpsController_isPreloading.set(this, false);
+        _PerpsController_isPreloadingUserData.set(this, false);
+        _PerpsController_preloadStateUnsubscribe.set(this, null);
+        _PerpsController_accountChangeUnsubscribe.set(this, null);
+        _PerpsController_previousIsTestnet.set(this, null);
+        _PerpsController_previousHip3ConfigVersion.set(this, null);
+        // Store options for dependency injection
+        __classPrivateFieldSet(this, _PerpsController_options, {
+            messenger,
+            state,
+            clientConfig,
+            infrastructure,
+        }, "f");
+        // Instantiate services with platform dependencies
+        // Services that need cross-controller access receive the messenger
+        __classPrivateFieldSet(this, _PerpsController_tradingService, new TradingService(infrastructure), "f");
+        __classPrivateFieldSet(this, _PerpsController_marketDataService, new MarketDataService(infrastructure), "f");
+        __classPrivateFieldSet(this, _PerpsController_accountService, new AccountService(infrastructure, messenger), "f");
+        __classPrivateFieldSet(this, _PerpsController_eligibilityService, new EligibilityService(infrastructure), "f");
+        __classPrivateFieldSet(this, _PerpsController_dataLakeService, new DataLakeService(infrastructure, messenger), "f");
+        __classPrivateFieldSet(this, _PerpsController_depositService, new DepositService(infrastructure, messenger), "f");
+        __classPrivateFieldSet(this, _PerpsController_featureFlagConfigurationService, new FeatureFlagConfigurationService(infrastructure), "f");
+        __classPrivateFieldSet(this, _PerpsController_rewardsIntegrationService, new RewardsIntegrationService(infrastructure, messenger), "f");
+        // Set HIP-3 fallback configuration from client (will be updated if remote flags available)
+        __classPrivateFieldSet(this, _PerpsController_hip3Enabled, clientConfig.fallbackHip3Enabled ?? false, "f");
+        __classPrivateFieldSet(this, _PerpsController_hip3AllowlistMarkets, [
+            ...(clientConfig.fallbackHip3AllowlistMarkets ?? []),
+        ], "f");
+        __classPrivateFieldSet(this, _PerpsController_hip3BlocklistMarkets, [
+            ...(clientConfig.fallbackHip3BlocklistMarkets ?? []),
+        ], "f");
+        // Immediately set the fallback region list since RemoteFeatureFlagController is empty by default and takes a moment to populate.
+        this.setBlockedRegionList(clientConfig.fallbackBlockedRegions ?? [], 'fallback');
+        /**
+         * Immediately read current state to catch any flags already loaded
+         * This is necessary to avoid race conditions where the RemoteFeatureFlagController fetches flags
+         * before the PerpsController initializes its RemoteFeatureFlagController subscription.
+         *
+         * We still subscribe in case the RemoteFeatureFlagController is not yet populated and updates later.
+         */
+        try {
+            const currentRemoteFeatureFlagState = this.messenger.call('RemoteFeatureFlagController:getState');
+            this.refreshEligibilityOnFeatureFlagChange(currentRemoteFeatureFlagState);
+        }
+        catch (error) {
+            // If we can't read the remote feature flags at construction time, we'll rely on:
+            // 1. The fallback blocked regions already set above
+            // 2. The subscription to catch updates when RemoteFeatureFlagController is ready
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.constructor'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'constructor', {
+                operation: 'readRemoteFeatureFlags',
+            }));
+        }
+        // Subscribe for the full controller lifetime — intentionally not stored;
+        // geo-blocking and HIP-3 flag propagation must remain active across
+        // disconnect → reconnect cycles and must never be torn down.
+        this.messenger.subscribe('RemoteFeatureFlagController:stateChange', this.refreshEligibilityOnFeatureFlagChange.bind(this));
+        this.providers = new Map();
+        // Migrate old persisted data without accountAddress
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_migrateRequestsIfNeeded).call(this);
+        this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+    }
+    /**
+     * Test-observable accessor for whether a standalone provider is cached.
+     *
+     * @returns True if a standalone provider instance exists.
+     */
+    hasStandaloneProvider() {
+        return __classPrivateFieldGet(this, _PerpsController_standaloneProvider, "f") !== null;
+    }
+    setBlockedRegionList(list, source) {
+        __classPrivateFieldGet(this, _PerpsController_featureFlagConfigurationService, "f").setBlockedRegions({
+            list,
+            source,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'setBlockedRegionList', {
+                getBlockedRegionList: () => this.blockedRegionList,
+                setBlockedRegionList: (newList, newSource) => {
+                    this.blockedRegionList = { list: newList, source: newSource };
+                    __classPrivateFieldSet(this, _PerpsController_blockedRegionListVersion, __classPrivateFieldGet(this, _PerpsController_blockedRegionListVersion, "f") + 1, "f");
+                },
+                refreshEligibility: () => this.refreshEligibility(),
+            }),
+        });
+    }
+    /**
+     * Respond to RemoteFeatureFlagController state changes
+     * Refreshes user eligibility based on geo-blocked regions defined in remote feature flag.
+     * Uses fallback configuration when remote feature flag is undefined.
+     * Note: Initial eligibility is set in the constructor if fallback regions are provided.
+     *
+     * @param remoteFeatureFlagControllerState - State from RemoteFeatureFlagController.
+     */
+    refreshEligibilityOnFeatureFlagChange(remoteFeatureFlagControllerState) {
+        __classPrivateFieldGet(this, _PerpsController_featureFlagConfigurationService, "f").refreshEligibility({
+            remoteFeatureFlagControllerState,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'refreshEligibilityOnFeatureFlagChange', {
+                getBlockedRegionList: () => this.blockedRegionList,
+                setBlockedRegionList: (list, source) => {
+                    this.blockedRegionList = { list, source };
+                    __classPrivateFieldSet(this, _PerpsController_blockedRegionListVersion, __classPrivateFieldGet(this, _PerpsController_blockedRegionListVersion, "f") + 1, "f");
+                },
+                refreshEligibility: () => this.refreshEligibility(),
+                getHip3Config: () => ({
+                    enabled: __classPrivateFieldGet(this, _PerpsController_hip3Enabled, "f"),
+                    allowlistMarkets: __classPrivateFieldGet(this, _PerpsController_hip3AllowlistMarkets, "f"),
+                    blocklistMarkets: __classPrivateFieldGet(this, _PerpsController_hip3BlocklistMarkets, "f"),
+                    source: __classPrivateFieldGet(this, _PerpsController_hip3ConfigSource, "f"),
+                }),
+                setHip3Config: (config) => {
+                    if (config.enabled !== undefined) {
+                        __classPrivateFieldSet(this, _PerpsController_hip3Enabled, config.enabled, "f");
+                    }
+                    if (config.allowlistMarkets !== undefined) {
+                        __classPrivateFieldSet(this, _PerpsController_hip3AllowlistMarkets, [...config.allowlistMarkets], "f");
+                    }
+                    if (config.blocklistMarkets !== undefined) {
+                        __classPrivateFieldSet(this, _PerpsController_hip3BlocklistMarkets, [...config.blocklistMarkets], "f");
+                    }
+                    if (config.source !== undefined) {
+                        __classPrivateFieldSet(this, _PerpsController_hip3ConfigSource, config.source, "f");
+                    }
+                },
+                incrementHip3ConfigVersion: () => {
+                    const newVersion = (this.state.hip3ConfigVersion || 0) + 1;
+                    this.update((state) => {
+                        state.hip3ConfigVersion = newVersion;
+                    });
+                    return newVersion;
+                },
+            }),
+        });
+    }
+    /**
+     * Initialize the PerpsController providers
+     * Must be called before using any other methods
+     * Prevents double initialization with promise caching
+     *
+     * @returns A promise that resolves when the operation completes.
+     */
+    async init() {
+        if (this.isInitialized) {
+            return undefined;
+        }
+        if (__classPrivateFieldGet(this, _PerpsController_initializationPromise, "f")) {
+            return __classPrivateFieldGet(this, _PerpsController_initializationPromise, "f");
+        }
+        __classPrivateFieldSet(this, _PerpsController_initializationPromise, __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_performInitialization).call(this), "f");
+        return __classPrivateFieldGet(this, _PerpsController_initializationPromise, "f");
+    }
+    /**
+     * Get the currently active provider.
+     * In aggregated mode, returns AggregatedPerpsProvider which routes to underlying providers.
+     * In single provider mode, returns HyperLiquidProvider directly.
+     *
+     * @returns The active provider (aggregated wrapper or direct provider based on mode)
+     * @throws Error if provider is not initialized or reinitializing
+     */
+    getActiveProvider() {
+        // Check if we're in the middle of reinitializing
+        if (this.isCurrentlyReinitializing()) {
+            this.update((state) => {
+                state.lastError = PERPS_ERROR_CODES.CLIENT_REINITIALIZING;
+                state.lastUpdateTimestamp = Date.now();
+            });
+            throw new Error(PERPS_ERROR_CODES.CLIENT_REINITIALIZING);
+        }
+        // Check if not initialized
+        if (this.state.initializationState !== InitializationState.Initialized ||
+            !this.isInitialized) {
+            const errorMessage = this.state.initializationState === InitializationState.Failed
+                ? `${PERPS_ERROR_CODES.CLIENT_NOT_INITIALIZED}: ${this.state.initializationError ?? 'Initialization failed'}`
+                : PERPS_ERROR_CODES.CLIENT_NOT_INITIALIZED;
+            this.update((state) => {
+                state.lastError = errorMessage;
+                state.lastUpdateTimestamp = Date.now();
+            });
+            throw new Error(errorMessage);
+        }
+        // Return the active provider instance (set during initialization based on providerMode)
+        if (!this.activeProviderInstance) {
+            this.update((state) => {
+                state.lastError = PERPS_ERROR_CODES.PROVIDER_NOT_AVAILABLE;
+                state.lastUpdateTimestamp = Date.now();
+            });
+            throw new Error(PERPS_ERROR_CODES.PROVIDER_NOT_AVAILABLE);
+        }
+        return this.activeProviderInstance;
+    }
+    /**
+     * Get the currently active provider, returning null if not available
+     * Use this method when the caller can gracefully handle a missing provider
+     * (e.g., UI components during initialization or reconnection)
+     *
+     * @returns The active provider, or null if not initialized/reinitializing
+     */
+    getActiveProviderOrNull() {
+        // Return null during reinitialization
+        if (this.isCurrentlyReinitializing()) {
+            return null;
+        }
+        // Return null if not initialized
+        if (this.state.initializationState !== InitializationState.Initialized ||
+            !this.isInitialized) {
+            return null;
+        }
+        // Return the active provider instance or null if not found
+        return this.activeProviderInstance ?? null;
+    }
+    /**
+     * Place a new order
+     * Thin delegation to TradingService
+     *
+     * @param params - The operation parameters.
+     * @returns The order result with order ID and status.
+     */
+    async placeOrder(params) {
+        const provider = this.getActiveProvider();
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_ensureTradingServiceDeps).call(this);
+        return __classPrivateFieldGet(this, _PerpsController_tradingService, "f").placeOrder({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'placeOrder', {
+                saveTradeConfiguration: (symbol, leverage) => this.saveTradeConfiguration(symbol, leverage),
+            }),
+            reportOrderToDataLake: (dataLakeParams) => this.reportOrderToDataLake(dataLakeParams),
+        });
+    }
+    /**
+     * Edit an existing order
+     * Thin delegation to TradingService
+     *
+     * @param params - The operation parameters.
+     * @returns The updated order result with order ID and status.
+     */
+    async editOrder(params) {
+        const provider = this.getActiveProvider();
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_ensureTradingServiceDeps).call(this);
+        return __classPrivateFieldGet(this, _PerpsController_tradingService, "f").editOrder({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'editOrder'),
+        });
+    }
+    /**
+     * Cancel an existing order
+     *
+     * @param params - The operation parameters.
+     * @returns The cancellation result with status.
+     */
+    async cancelOrder(params) {
+        const provider = this.getActiveProvider();
+        return __classPrivateFieldGet(this, _PerpsController_tradingService, "f").cancelOrder({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'cancelOrder'),
+        });
+    }
+    /**
+     * Cancel multiple orders in parallel
+     * Batch version of cancelOrder() that cancels multiple orders simultaneously
+     *
+     * @param params - The operation parameters.
+     * @returns The batch cancellation results for each order.
+     */
+    async cancelOrders(params) {
+        const provider = this.getActiveProvider();
+        return __classPrivateFieldGet(this, _PerpsController_tradingService, "f").cancelOrders({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'cancelOrders', {
+                getOpenOrders: () => this.getOpenOrders(),
+            }),
+            withStreamPause: (operation, channels) => __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_withStreamPause).call(this, operation, channels),
+        });
+    }
+    /**
+     * Close a position (partial or full)
+     * Thin delegation to TradingService
+     *
+     * @param params - The operation parameters.
+     * @returns The order result from the close position request.
+     */
+    async closePosition(params) {
+        const provider = this.getActiveProvider();
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_ensureTradingServiceDeps).call(this);
+        return __classPrivateFieldGet(this, _PerpsController_tradingService, "f").closePosition({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'closePosition', {
+                getPositions: () => this.getPositions(),
+            }),
+            reportOrderToDataLake: (dataLakeParams) => this.reportOrderToDataLake(dataLakeParams),
+        });
+    }
+    /**
+     * Close multiple positions in parallel
+     * Batch version of closePosition() that closes multiple positions simultaneously
+     *
+     * @param params - The operation parameters.
+     * @returns The batch close results for each position.
+     */
+    async closePositions(params) {
+        const provider = this.getActiveProvider();
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_ensureTradingServiceDeps).call(this);
+        return __classPrivateFieldGet(this, _PerpsController_tradingService, "f").closePositions({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'closePositions', {
+                getPositions: () => this.getPositions(),
+            }),
+        });
+    }
+    /**
+     * Update TP/SL for an existing position
+     *
+     * @param params - The operation parameters.
+     * @returns The order result from the TP/SL update.
+     */
+    async updatePositionTPSL(params) {
+        const provider = this.getActiveProvider();
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_ensureTradingServiceDeps).call(this);
+        return __classPrivateFieldGet(this, _PerpsController_tradingService, "f").updatePositionTPSL({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'updatePositionTPSL'),
+        });
+    }
+    /**
+     * Update margin for an existing position (add or remove)
+     *
+     * @param params - The operation parameters.
+     * @returns The margin update result.
+     */
+    async updateMargin(params) {
+        const provider = this.getActiveProvider();
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_ensureTradingServiceDeps).call(this);
+        return __classPrivateFieldGet(this, _PerpsController_tradingService, "f").updateMargin({
+            provider,
+            symbol: params.symbol,
+            amount: params.amount,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'updateMargin'),
+        });
+    }
+    /**
+     * Flip position (reverse direction while keeping size and leverage)
+     *
+     * @param params - The operation parameters.
+     * @returns The order result from the position flip.
+     */
+    async flipPosition(params) {
+        const provider = this.getActiveProvider();
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_ensureTradingServiceDeps).call(this);
+        return __classPrivateFieldGet(this, _PerpsController_tradingService, "f").flipPosition({
+            provider,
+            position: params.position,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'flipPosition'),
+        });
+    }
+    /**
+     * Simplified deposit method that prepares transaction for confirmation screen
+     * No complex state tracking - just sets a loading flag
+     *
+     * @param params - Parameters for the deposit flow
+     * @param params.amount - Optional deposit amount
+     * @param params.placeOrder - If true, uses addTransaction instead of submit to avoid navigation
+     * @returns An object containing a promise that resolves to the transaction hash.
+     */
+    async depositWithConfirmation(params = {}) {
+        const { amount, placeOrder } = params;
+        let currentDepositId;
+        try {
+            // Clear any stale results when starting a new deposit flow
+            // Don't set depositInProgress yet - wait until user confirms
+            // Prepare deposit transaction using DepositService
+            const provider = this.getActiveProvider();
+            const { transaction, assetChainId, currentDepositId: depositId, } = await __classPrivateFieldGet(this, _PerpsController_depositService, "f").prepareTransaction({ provider });
+            currentDepositId = depositId;
+            // Get current account address via messenger (outside of update() for proper typing)
+            const evmAccount = getSelectedEvmAccount(this.messenger.call('AccountTreeController:getAccountsFromSelectedAccountGroup'));
+            const accountAddress = evmAccount?.address ?? 'unknown';
+            this.update((state) => {
+                state.lastDepositResult = null;
+                // Add deposit request to tracking
+                const depositRequest = {
+                    id: currentDepositId ?? uuidv4(),
+                    timestamp: Date.now(),
+                    amount: amount ?? '0', // Use provided amount or default to '0'
+                    asset: USDC_SYMBOL,
+                    accountAddress, // Track which account initiated deposit
+                    success: false, // Will be updated when transaction completes
+                    txHash: undefined,
+                    status: 'pending',
+                    source: undefined,
+                    transactionId: undefined, // Will be set to depositId when available
+                };
+                state.depositRequests.unshift(depositRequest); // Add to beginning of array
+            });
+            const networkClientId = __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_findNetworkClientIdForChain).call(this, assetChainId);
+            if (!networkClientId) {
+                throw new Error(`No network client found for chain ${assetChainId}. Please add the network first.`);
+            }
+            let result;
+            let transactionMeta;
+            let depositOrderResult = null;
+            const defaultTransactionOptions = {
+                networkClientId,
+                origin: ORIGIN_METAMASK,
+                skipInitialGasEstimate: true,
+            };
+            if (placeOrder) {
+                // Use addTransaction to create transaction without navigating to confirmation screen
+                const addResult = await __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_submitTransaction).call(this, transaction, {
+                    ...defaultTransactionOptions,
+                    type: 'perpsDepositAndOrder',
+                });
+                transactionMeta = addResult.transactionMeta;
+                // Return transaction ID immediately (fire-and-forget for caller)
+                result = Promise.resolve(transactionMeta.id);
+                // Track deposit request lifecycle via the real transaction result
+                depositOrderResult = addResult.result;
+            }
+            else {
+                // submit shows the confirmation screen and returns a promise
+                // The promise will resolve when transaction completes or reject if cancelled/failed
+                const submitResult = await __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_submitTransaction).call(this, transaction, {
+                    ...defaultTransactionOptions,
+                    type: 'perpsDeposit',
+                });
+                result = submitResult.result;
+                transactionMeta = submitResult.transactionMeta;
+            }
+            // Store the transaction ID and try to get amount from transaction
+            this.update((state) => {
+                state.lastDepositTransactionId = transactionMeta.id;
+            });
+            // Track the transaction lifecycle only when using submit (deposit-only flow)
+            if (!placeOrder) {
+                // At this point, the confirmation modal is shown to the user
+                // The result promise will resolve/reject based on user action and transaction outcome
+                // Track the transaction lifecycle
+                // The result promise will resolve/reject based on user action and transaction outcome
+                // Note: We intentionally don't set depositInProgress immediately to avoid
+                // showing toasts before the user confirms the transaction
+                // TODO: @abretonc7s Find a better way to trigger our custom toast notification then having to toggle the state
+                // How to replace the system notifications?
+                result
+                    .then((actualTxHash) => {
+                    // Transaction was successfully completed
+                    // Set depositInProgress to true temporarily to show success
+                    this.update((state) => {
+                        state.depositInProgress = true;
+                        state.lastDepositResult = {
+                            success: true,
+                            txHash: actualTxHash,
+                            amount: amount ?? '0',
+                            asset: USDC_SYMBOL, // Default asset for deposits
+                            timestamp: Date.now(),
+                            error: '',
+                        };
+                        // Update the deposit request by request ID to avoid race conditions
+                        if (state.depositRequests.length > 0) {
+                            const requestToUpdate = state.depositRequests.find((req) => req.id === currentDepositId);
+                            if (requestToUpdate) {
+                                // For deposits, we have a txHash immediately, so mark as completed
+                                // (the transaction hash means the deposit was successful)
+                                requestToUpdate.status = 'completed';
+                                requestToUpdate.success = true;
+                                requestToUpdate.txHash = actualTxHash;
+                            }
+                        }
+                    });
+                    // Clear depositInProgress after a short delay
+                    setTimeout(() => {
+                        this.update((state) => {
+                            state.depositInProgress = false;
+                            state.lastDepositTransactionId = null;
+                        });
+                    }, 100);
+                    return undefined;
+                })
+                    .catch((error) => {
+                    // Check if user denied/cancelled the transaction
+                    const errorMessage = ensureError(error, 'PerpsController.initiateDeposit').message;
+                    const userCancelled = errorMessage.includes('User denied') ||
+                        errorMessage.includes('User rejected') ||
+                        errorMessage.includes('User cancelled') ||
+                        errorMessage.includes('User canceled');
+                    if (userCancelled) {
+                        // User cancelled - clear any state, no toast
+                        this.update((state) => {
+                            state.depositInProgress = false;
+                            state.lastDepositTransactionId = null;
+                            // Don't set lastDepositResult - no toast needed
+                            // Mark deposit request as cancelled
+                            const requestToUpdate = state.depositRequests.find((req) => req.id === currentDepositId);
+                            if (requestToUpdate) {
+                                requestToUpdate.status = 'cancelled';
+                                requestToUpdate.success = false;
+                            }
+                        });
+                    }
+                    else {
+                        // Transaction failed after confirmation - show error toast
+                        this.update((state) => {
+                            state.depositInProgress = false;
+                            state.lastDepositTransactionId = null;
+                            state.lastDepositResult = {
+                                success: false,
+                                error: errorMessage,
+                                amount: amount ?? '0',
+                                asset: USDC_SYMBOL, // Default asset for deposits
+                                timestamp: Date.now(),
+                                txHash: '',
+                            };
+                            // Update the deposit request by request ID to avoid race conditions
+                            if (state.depositRequests.length > 0) {
+                                const requestToUpdate = state.depositRequests.find((req) => req.id === currentDepositId);
+                                if (requestToUpdate) {
+                                    requestToUpdate.status = 'failed';
+                                    requestToUpdate.success = false;
+                                }
+                            }
+                        });
+                    }
+                });
+            }
+            else if (depositOrderResult) {
+                // Track deposit request lifecycle for deposit+order flow
+                depositOrderResult
+                    .then((actualTxHash) => {
+                    this.update((state) => {
+                        const requestToUpdate = state.depositRequests.find((req) => req.id === currentDepositId);
+                        if (requestToUpdate) {
+                            requestToUpdate.status = 'completed';
+                            requestToUpdate.success = true;
+                            requestToUpdate.txHash = actualTxHash;
+                        }
+                    });
+                    return undefined;
+                })
+                    .catch((error) => {
+                    const errorMessage = ensureError(error, 'PerpsController.depositWithOrder').message;
+                    const isCancellation = errorMessage.includes('User denied') ||
+                        errorMessage.includes('User rejected') ||
+                        errorMessage.includes('cancelled') ||
+                        errorMessage.includes('canceled');
+                    this.update((state) => {
+                        const requestToUpdate = state.depositRequests.find((req) => req.id === currentDepositId);
+                        if (requestToUpdate) {
+                            requestToUpdate.status = (isCancellation ? 'cancelled' : 'failed');
+                            requestToUpdate.success = false;
+                        }
+                    });
+                });
+            }
+            return {
+                result,
+            };
+        }
+        catch (error) {
+            // Check if user denied/cancelled the transaction
+            const errorMessage = ensureError(error, 'PerpsController.initiateDeposit').message;
+            const userCancelled = errorMessage.includes('User denied') ||
+                errorMessage.includes('User rejected') ||
+                errorMessage.includes('User cancelled') ||
+                errorMessage.includes('User canceled');
+            if (!userCancelled) {
+                // Only track actual errors, not user cancellations
+                this.update((state) => {
+                    state.lastDepositTransactionId = null;
+                    // Note: lastDepositResult is already set in the catch block above
+                    // Mark deposit request as failed if one was created
+                    if (currentDepositId) {
+                        const request = state.depositRequests.find((req) => req.id === currentDepositId);
+                        if (request) {
+                            request.status = 'failed';
+                            request.success = false;
+                        }
+                    }
+                });
+            }
+            throw error;
+        }
+    }
+    /**
+     * Same as depositWithConfirmation - prepares transaction for confirmation screen.
+     *
+     * @returns A promise that resolves to the string result.
+     */
+    async depositWithOrder() {
+        return this.depositWithConfirmation({ placeOrder: true });
+    }
+    /**
+     * Clear the last deposit result after it has been shown to the user
+     */
+    clearDepositResult() {
+        this.update((state) => {
+            state.lastDepositResult = null;
+        });
+    }
+    clearWithdrawResult() {
+        this.update((state) => {
+            state.lastWithdrawResult = null;
+        });
+    }
+    /**
+     * Update withdrawal request status when it completes
+     * This is called when a withdrawal is matched with a completed withdrawal from the API
+     *
+     * @param withdrawalId - The withdrawal transaction ID.
+     * @param status - The current status.
+     * @param txHash - The transaction hash.
+     */
+    updateWithdrawalStatus(withdrawalId, status, txHash) {
+        let withdrawalAmount;
+        let shouldTrack = false;
+        let found = false;
+        this.update((state) => {
+            const withdrawalIndex = state.withdrawalRequests.findIndex((request) => request.id === withdrawalId);
+            if (withdrawalIndex >= 0) {
+                found = true;
+                const request = state.withdrawalRequests[withdrawalIndex];
+                withdrawalAmount = request.amount;
+                shouldTrack =
+                    withdrawalAmount !== undefined && request.status !== status;
+                request.status = status;
+                request.success = status === 'completed';
+                if (txHash) {
+                    request.txHash = txHash;
+                }
+                // Clear withdrawal progress when withdrawal completes
+                if (status === 'completed' || status === 'failed') {
+                    state.withdrawalProgress = {
+                        progress: 0,
+                        lastUpdated: Date.now(),
+                        activeWithdrawalId: null,
+                    };
+                }
+            }
+        });
+        if (shouldTrack && withdrawalAmount !== undefined) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getMetrics).call(this).trackPerpsEvent(PerpsAnalyticsEvent.WithdrawalTransaction, {
+                [PERPS_EVENT_PROPERTY.STATUS]: status === 'completed'
+                    ? PERPS_EVENT_VALUE.STATUS.COMPLETED
+                    : PERPS_EVENT_VALUE.STATUS.FAILED,
+                [PERPS_EVENT_PROPERTY.WITHDRAWAL_AMOUNT]: Number.parseFloat(withdrawalAmount),
+            });
+        }
+        if (found) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Updated withdrawal status', {
+                withdrawalId,
+                status,
+                txHash,
+            });
+        }
+    }
+    /**
+     * Update withdrawal progress (persistent across navigation)
+     *
+     * @param progress - The progress indicator.
+     * @param activeWithdrawalId - The active withdrawal ID.
+     */
+    updateWithdrawalProgress(progress, activeWithdrawalId = null) {
+        this.update((state) => {
+            state.withdrawalProgress = {
+                progress,
+                lastUpdated: Date.now(),
+                activeWithdrawalId,
+            };
+        });
+    }
+    /**
+     * Get current withdrawal progress
+     *
+     * @returns The withdrawal progress, last update timestamp, and active withdrawal ID.
+     */
+    getWithdrawalProgress() {
+        return this.state.withdrawalProgress;
+    }
+    /**
+     * Withdraw funds from trading account
+     *
+     * The withdrawal process varies by provider and may involve:
+     * - Direct on-chain transfers
+     * - Bridge operations
+     * - Multi-step validation processes
+     *
+     * Check the specific provider documentation for detailed withdrawal flows.
+     *
+     * @param params Withdrawal parameters
+     * @returns WithdrawResult with withdrawal ID and tracking info
+     */
+    async withdraw(params) {
+        const provider = this.getActiveProvider();
+        return __classPrivateFieldGet(this, _PerpsController_accountService, "f").withdraw({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'withdraw'),
+            refreshAccountState: async () => {
+                await this.getAccountState({ source: 'post_withdrawal' });
+            },
+        });
+    }
+    /**
+     * Get current positions
+     * Thin delegation to MarketDataService
+     *
+     * For standalone mode, bypasses getActiveProvider() to allow position queries
+     * without full perps initialization (e.g., for showing positions on token details page)
+     *
+     * @param params - The operation parameters.
+     * @returns Array of open positions for the active provider.
+     */
+    async getPositions(params) {
+        // For standalone mode, access provider directly without initialization check
+        // This allows discovery use cases (checking if user has positions) without full perps setup
+        if (params?.standalone && params.userAddress) {
+            // Use activeProviderInstance if available (respects provider abstraction)
+            // Fallback to cached standalone provider for pre-initialization discovery
+            // TODO: When adding new providers (MYX), consider a provider factory pattern
+            const provider = this.activeProviderInstance ?? __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getOrCreateStandaloneProvider).call(this);
+            return provider.getPositions(params);
+        }
+        const provider = this.getActiveProvider();
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").getPositions({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'getPositions'),
+        });
+    }
+    /**
+     * Get historical user fills (trade executions)
+     * Thin delegation to MarketDataService
+     *
+     * @param params - The operation parameters.
+     * @returns Array of historical trade executions (fills).
+     */
+    async getOrderFills(params) {
+        const provider = this.getActiveProvider();
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").getOrderFills({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'getOrderFills'),
+        });
+    }
+    /**
+     * Get historical user orders (order lifecycle)
+     * Thin delegation to MarketDataService
+     *
+     * @param params - The operation parameters.
+     * @returns Array of historical orders.
+     */
+    async getOrders(params) {
+        const provider = this.getActiveProvider();
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").getOrders({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'getOrders'),
+        });
+    }
+    /**
+     * Get currently open orders (real-time status)
+     * Thin delegation to MarketDataService
+     *
+     * For standalone mode, bypasses getActiveProvider() to allow open order queries
+     * without full perps initialization (e.g., for background preloading)
+     *
+     * @param params - The operation parameters.
+     * @returns A promise that resolves to the result.
+     */
+    async getOpenOrders(params) {
+        // For standalone mode, access provider directly without initialization check
+        if (params?.standalone && params.userAddress) {
+            const provider = this.activeProviderInstance ?? __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getOrCreateStandaloneProvider).call(this);
+            return provider.getOpenOrders(params);
+        }
+        const provider = this.getActiveProvider();
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").getOpenOrders({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'getOpenOrders'),
+        });
+    }
+    /**
+     * Get historical user funding history (funding payments)
+     * Thin delegation to MarketDataService
+     *
+     * @param params - The operation parameters.
+     * @returns Array of historical funding payments.
+     */
+    async getFunding(params) {
+        const provider = this.getActiveProvider();
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").getFunding({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'getFunding'),
+        });
+    }
+    /**
+     * Get account state (balances, etc.)
+     * Thin delegation to MarketDataService
+     *
+     * For standalone mode, bypasses getActiveProvider() to allow account state queries
+     * without full perps initialization (e.g., for checking if user has perps funds)
+     *
+     * @param params - The operation parameters.
+     * @returns A promise that resolves to the result.
+     */
+    async getAccountState(params) {
+        // For standalone mode, access provider directly without initialization check
+        // This allows discovery use cases (checking if user has perps funds) without full perps setup
+        if (params?.standalone && params.userAddress) {
+            // Use activeProviderInstance if available (respects provider abstraction)
+            // Fallback to cached standalone provider for pre-initialization discovery
+            const provider = this.activeProviderInstance ?? __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getOrCreateStandaloneProvider).call(this);
+            return provider.getAccountState(params);
+        }
+        const provider = this.getActiveProvider();
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").getAccountState({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'getAccountState'),
+        });
+    }
+    /**
+     * Get historical portfolio data
+     * Thin delegation to MarketDataService
+     *
+     * @param params - The operation parameters.
+     * @returns The historical portfolio data points.
+     */
+    async getHistoricalPortfolio(params) {
+        const provider = this.getActiveProvider();
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").getHistoricalPortfolio({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'getHistoricalPortfolio'),
+        });
+    }
+    /**
+     * Get available markets with optional filtering
+     * Thin delegation to MarketDataService
+     *
+     * For standalone mode, bypasses getActiveProvider() to allow market discovery
+     * without full perps initialization (e.g., for discovery banners on spot screens)
+     *
+     * @param params - The operation parameters.
+     * @returns Array of available markets matching the filter criteria.
+     */
+    async getMarkets(params) {
+        // For standalone mode, access provider directly without initialization check
+        // This allows discovery use cases (checking if market exists) without full perps setup
+        if (params?.standalone) {
+            // Use activeProviderInstance if available (respects provider abstraction)
+            // Fallback to cached standalone provider for pre-initialization discovery
+            const provider = this.activeProviderInstance ?? __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getOrCreateStandaloneProvider).call(this);
+            return provider.getMarkets(params);
+        }
+        const provider = this.getActiveProvider();
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").getMarkets({
+            provider,
+            params,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'getMarkets'),
+        });
+    }
+    /**
+     * Get market data with prices (includes price, volume, 24h change)
+     *
+     * For standalone mode, bypasses getActiveProvider() to allow market data queries
+     * without full perps initialization (e.g., for background preloading on app start)
+     *
+     * @param params - The operation parameters.
+     * @param params.standalone - Whether to use standalone mode.
+     * @returns A promise that resolves to the market data.
+     */
+    async getMarketDataWithPrices(params) {
+        if (params?.standalone) {
+            // Use activeProviderInstance if available (respects provider abstraction)
+            // Fallback to cached standalone provider for pre-initialization discovery
+            const provider = this.activeProviderInstance ?? __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getOrCreateStandaloneProvider).call(this);
+            return provider.getMarketDataWithPrices();
+        }
+        const provider = this.getActiveProvider();
+        return provider.getMarketDataWithPrices();
+    }
+    /**
+     * Start background market data preloading.
+     * Fetches market data immediately and refreshes every 5 minutes.
+     * Watches for isTestnet and hip3ConfigVersion changes to re-preload.
+     */
+    startMarketDataPreload() {
+        if (__classPrivateFieldGet(this, _PerpsController_preloadTimer, "f")) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Preload already started, skipping');
+            return;
+        }
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Starting market data preload');
+        // Track current values for change detection
+        __classPrivateFieldSet(this, _PerpsController_previousIsTestnet, this.state.isTestnet, "f");
+        __classPrivateFieldSet(this, _PerpsController_previousHip3ConfigVersion, this.state.hip3ConfigVersion, "f");
+        // Immediate preload
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_performMarketDataPreload).call(this).catch(() => {
+            /* fire-and-forget */
+        });
+        // Periodic refresh
+        __classPrivateFieldSet(this, _PerpsController_preloadTimer, setInterval(() => {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_performMarketDataPreload).call(this).catch(() => {
+                /* fire-and-forget */
+            });
+        }, __classPrivateFieldGet(_a, _a, "f", _PerpsController_preloadRefreshMs)), "f");
+        // Watch for isTestnet / hip3ConfigVersion / cachedUserDataAddress changes
+        const handler = (_state, patches) => {
+            // Early-return when no watched field changed (skips ~46 unrelated updates)
+            const hasRelevantChange = patches.some((patch) => typeof patch.path[0] === 'string' &&
+                __classPrivateFieldGet(_a, _a, "f", _PerpsController_preloadWatchedPaths).has(patch.path[0]));
+            if (!hasRelevantChange) {
+                return;
+            }
+            const currentIsTestnet = this.state.isTestnet;
+            const currentHip3Version = this.state.hip3ConfigVersion;
+            const testnetChanged = currentIsTestnet !== __classPrivateFieldGet(this, _PerpsController_previousIsTestnet, "f");
+            const hip3Changed = currentHip3Version !== __classPrivateFieldGet(this, _PerpsController_previousHip3ConfigVersion, "f");
+            if (testnetChanged || hip3Changed) {
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Network/config changed, re-preloading', {
+                    testnetChanged,
+                    hip3Changed,
+                    isTestnet: currentIsTestnet,
+                    hip3ConfigVersion: currentHip3Version,
+                });
+                __classPrivateFieldSet(this, _PerpsController_previousIsTestnet, currentIsTestnet, "f");
+                __classPrivateFieldSet(this, _PerpsController_previousHip3ConfigVersion, currentHip3Version, "f");
+                // Clear stale cache (market + user data)
+                this.update((state) => {
+                    state.cachedMarketData = null;
+                    state.cachedMarketDataTimestamp = 0;
+                    state.cachedPositions = null;
+                    state.cachedOrders = null;
+                    state.cachedAccountState = null;
+                    state.cachedUserDataTimestamp = 0;
+                    state.cachedUserDataAddress = null;
+                });
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_performMarketDataPreload).call(this).catch(() => {
+                    /* fire-and-forget */
+                });
+            }
+        };
+        this.messenger.subscribe('PerpsController:stateChange', handler);
+        __classPrivateFieldSet(this, _PerpsController_preloadStateUnsubscribe, () => {
+            this.messenger.unsubscribe('PerpsController:stateChange', handler);
+        }, "f");
+        // Watch for account changes via AccountTreeController
+        const accountChangeHandler = () => {
+            const evmAccount = getSelectedEvmAccount(this.messenger.call('AccountTreeController:getAccountsFromSelectedAccountGroup'));
+            const currentAddress = evmAccount?.address ?? null;
+            // If there's cached data from a different account (or no EVM account now), clear it
+            if (this.state.cachedUserDataAddress !== null &&
+                currentAddress !== this.state.cachedUserDataAddress) {
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Account changed, clearing user data cache');
+                this.update((state) => {
+                    state.cachedPositions = null;
+                    state.cachedOrders = null;
+                    state.cachedAccountState = null;
+                    state.cachedUserDataTimestamp = 0;
+                    state.cachedUserDataAddress = null;
+                });
+                // Only preload if the new account is an EVM account
+                if (currentAddress) {
+                    __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_performUserDataPreload).call(this).catch(() => {
+                        /* fire-and-forget */
+                    });
+                }
+            }
+        };
+        this.messenger.subscribe('AccountTreeController:selectedAccountGroupChange', accountChangeHandler);
+        __classPrivateFieldSet(this, _PerpsController_accountChangeUnsubscribe, () => {
+            this.messenger.unsubscribe('AccountTreeController:selectedAccountGroupChange', accountChangeHandler);
+        }, "f");
+    }
+    /**
+     * Stop background market data preloading.
+     */
+    stopMarketDataPreload() {
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Stopping market data preload');
+        if (__classPrivateFieldGet(this, _PerpsController_preloadTimer, "f")) {
+            clearInterval(__classPrivateFieldGet(this, _PerpsController_preloadTimer, "f"));
+            __classPrivateFieldSet(this, _PerpsController_preloadTimer, null, "f");
+        }
+        if (__classPrivateFieldGet(this, _PerpsController_preloadStateUnsubscribe, "f")) {
+            __classPrivateFieldGet(this, _PerpsController_preloadStateUnsubscribe, "f").call(this);
+            __classPrivateFieldSet(this, _PerpsController_preloadStateUnsubscribe, null, "f");
+        }
+        if (__classPrivateFieldGet(this, _PerpsController_accountChangeUnsubscribe, "f")) {
+            __classPrivateFieldGet(this, _PerpsController_accountChangeUnsubscribe, "f").call(this);
+            __classPrivateFieldSet(this, _PerpsController_accountChangeUnsubscribe, null, "f");
+        }
+        __classPrivateFieldSet(this, _PerpsController_previousIsTestnet, null, "f");
+        __classPrivateFieldSet(this, _PerpsController_previousHip3ConfigVersion, null, "f");
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_cleanupStandaloneProvider).call(this).catch(() => {
+            /* fire-and-forget to preserve sync signature */
+        });
+    }
+    /**
+     * Get list of available HIP-3 builder-deployed DEXs
+     *
+     * @param params - Optional parameters for filtering
+     * @returns Array of DEX names
+     */
+    async getAvailableDexs(params) {
+        const provider = this.getActiveProvider();
+        const context = __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'getAvailableDexs');
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").getAvailableDexs({
+            provider,
+            params,
+            context,
+        });
+    }
+    /**
+     * Fetch historical candle data
+     * Thin delegation to MarketDataService
+     *
+     * @param options - The configuration options.
+     * @param options.symbol - The trading pair symbol.
+     * @param options.interval - The candle interval period.
+     * @param options.limit - Maximum number of items to fetch.
+     * @param options.endTime - End timestamp in milliseconds.
+     * @returns The historical candle data for the requested symbol and interval.
+     */
+    async fetchHistoricalCandles(options) {
+        const { symbol, interval, limit = 100, endTime } = options;
+        const provider = this.getActiveProvider();
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").fetchHistoricalCandles({
+            provider,
+            symbol,
+            interval,
+            limit,
+            endTime,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'fetchHistoricalCandles'),
+        });
+    }
+    /**
+     * Calculate liquidation price for a position
+     * Uses provider-specific formulas based on protocol rules
+     *
+     * @param params - The operation parameters.
+     * @returns A promise that resolves to the string result.
+     */
+    async calculateLiquidationPrice(params) {
+        const provider = this.getActiveProvider();
+        const context = __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'calculateLiquidationPrice');
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").calculateLiquidationPrice({
+            provider,
+            params,
+            context,
+        });
+    }
+    /**
+     * Calculate maintenance margin for a specific asset
+     * Returns a percentage (e.g., 0.0125 for 1.25%)
+     *
+     * @param params - The operation parameters.
+     * @returns A promise that resolves to the numeric result.
+     */
+    async calculateMaintenanceMargin(params) {
+        const provider = this.getActiveProvider();
+        const context = __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'calculateMaintenanceMargin');
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").calculateMaintenanceMargin({
+            provider,
+            params,
+            context,
+        });
+    }
+    /**
+     * Get maximum leverage allowed for an asset
+     *
+     * @param asset - The asset identifier.
+     * @returns A promise that resolves to the numeric result.
+     */
+    async getMaxLeverage(asset) {
+        const provider = this.getActiveProvider();
+        const context = __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'getMaxLeverage');
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").getMaxLeverage({ provider, asset, context });
+    }
+    /**
+     * Validate order parameters according to protocol-specific rules
+     *
+     * @param params - The operation parameters.
+     * @returns True if the condition is met.
+     */
+    async validateOrder(params) {
+        const provider = this.getActiveProvider();
+        const context = __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'validateOrder');
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").validateOrder({ provider, params, context });
+    }
+    /**
+     * Validate close position parameters according to protocol-specific rules
+     *
+     * @param params - The operation parameters.
+     * @returns A promise that resolves to the result.
+     */
+    async validateClosePosition(params) {
+        const provider = this.getActiveProvider();
+        const context = __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'validateClosePosition');
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").validateClosePosition({
+            provider,
+            params,
+            context,
+        });
+    }
+    /**
+     * Validate withdrawal parameters according to protocol-specific rules
+     *
+     * @param params - The operation parameters.
+     * @returns True if the condition is met.
+     */
+    async validateWithdrawal(params) {
+        const provider = this.getActiveProvider();
+        return __classPrivateFieldGet(this, _PerpsController_accountService, "f").validateWithdrawal({ provider, params });
+    }
+    /**
+     * Get supported withdrawal routes - returns complete asset and routing information
+     *
+     * @returns Array of supported asset routes for withdrawals.
+     */
+    getWithdrawalRoutes() {
+        try {
+            const provider = this.getActiveProvider();
+            return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").getWithdrawalRoutes({ provider });
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.getWithdrawalRoutes'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'getWithdrawalRoutes'));
+            // Return empty array if provider is not available
+            return [];
+        }
+    }
+    /**
+     * Toggle between testnet and mainnet
+     *
+     * @returns The toggle result with success status and current network mode.
+     */
+    async toggleTestnet() {
+        // Prevent concurrent reinitializations
+        if (this.isCurrentlyReinitializing()) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Already reinitializing, skipping toggle', {
+                timestamp: new Date().toISOString(),
+            });
+            return {
+                success: false,
+                isTestnet: this.state.isTestnet,
+                error: PERPS_ERROR_CODES.CLIENT_REINITIALIZING,
+            };
+        }
+        __classPrivateFieldSet(this, _PerpsController_isReinitializing, true, "f");
+        // Store previous isTestnet for rollback on failure
+        const previousIsTestnet = this.state.isTestnet;
+        try {
+            await __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_cleanupStandaloneProvider).call(this);
+            const previousNetwork = previousIsTestnet ? 'testnet' : 'mainnet';
+            this.update((state) => {
+                state.isTestnet = !state.isTestnet;
+            });
+            const newNetwork = this.state.isTestnet ? 'testnet' : 'mainnet';
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Network toggle initiated', {
+                from: previousNetwork,
+                to: newNetwork,
+                timestamp: new Date().toISOString(),
+            });
+            // Reset initialization state and reinitialize provider with new testnet setting
+            this.isInitialized = false;
+            __classPrivateFieldSet(this, _PerpsController_initializationPromise, null, "f");
+            await this.init();
+            // Check if initialization actually succeeded — performInitialization()
+            // does not throw on failure, it sets state to Failed and resolves.
+            if (this.state.initializationState === InitializationState.Failed) {
+                throw new Error(this.state.initializationError ??
+                    'Network toggle initialization failed');
+            }
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Network toggle completed', {
+                newNetwork,
+                isTestnet: this.state.isTestnet,
+                timestamp: new Date().toISOString(),
+            });
+            return { success: true, isTestnet: this.state.isTestnet };
+        }
+        catch (error) {
+            // Rollback isTestnet to previous value
+            this.update((state) => {
+                state.isTestnet = previousIsTestnet;
+            });
+            return {
+                success: false,
+                isTestnet: this.state.isTestnet,
+                error: ensureError(error, 'PerpsController.toggleTestnet').message,
+            };
+        }
+        finally {
+            __classPrivateFieldSet(this, _PerpsController_isReinitializing, false, "f");
+        }
+    }
+    /**
+     * Switch to a different provider
+     * Uses a full reinit approach: disconnect() → update state → init()
+     * This ensures complete state reset including WebSocket connections and caches.
+     *
+     * @param providerId - The provider identifier.
+     * @returns The switch result with success status and active provider.
+     */
+    async switchProvider(providerId) {
+        // No-op if already on this provider (regardless of init state)
+        if (this.state.activeProvider === providerId) {
+            return { success: true, providerId };
+        }
+        // Validate provider is available
+        // 'aggregated' is always valid, individual providers must exist in the map
+        const isValidProvider = providerId === 'aggregated' || this.providers.has(providerId);
+        if (!isValidProvider) {
+            return {
+                success: false,
+                providerId: this.state.activeProvider,
+                error: `Provider ${providerId} not available`,
+            };
+        }
+        // Prevent concurrent switches
+        if (this.isCurrentlyReinitializing()) {
+            return {
+                success: false,
+                providerId: this.state.activeProvider,
+                error: PERPS_ERROR_CODES.CLIENT_REINITIALIZING,
+            };
+        }
+        __classPrivateFieldSet(this, _PerpsController_isReinitializing, true, "f");
+        // Store previous provider for rollback on failure
+        const previousProvider = this.state.activeProvider;
+        try {
+            await __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_cleanupStandaloneProvider).call(this);
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Provider switch initiated', {
+                from: previousProvider,
+                to: providerId,
+                timestamp: new Date().toISOString(),
+            });
+            // Provider disconnect is handled by performInitialization() during
+            // reinitialization. The disconnect() method skips provider teardown
+            // when isReinitializing is true to prevent double-disconnect.
+            // Update state with new provider
+            this.update((state) => {
+                state.activeProvider = providerId;
+                state.accountState = null;
+                state.initializationState = InitializationState.Uninitialized;
+            });
+            // Reset initialization state and reinitialize
+            this.isInitialized = false;
+            __classPrivateFieldSet(this, _PerpsController_initializationPromise, null, "f");
+            await this.init();
+            // Check if initialization actually succeeded — performInitialization()
+            // does not throw on failure, it sets state to Failed and resolves.
+            if (this.state.initializationState === InitializationState.Failed) {
+                throw new Error(this.state.initializationError ?? 'Provider initialization failed');
+            }
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Provider switch completed', {
+                providerId,
+                timestamp: new Date().toISOString(),
+            });
+            return { success: true, providerId };
+        }
+        catch (error) {
+            // Rollback state to previous provider
+            this.update((state) => {
+                state.activeProvider = previousProvider;
+            });
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.switchProvider'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'switchProvider', { providerId }));
+            // Attempt to reinitialize the previous provider via init(),
+            // which handles all provider modes including 'aggregated'.
+            try {
+                this.isInitialized = false;
+                __classPrivateFieldSet(this, _PerpsController_initializationPromise, null, "f");
+                await this.init();
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Rollback to previous provider succeeded', {
+                    previousProvider,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+            catch (reinitError) {
+                // Reinit also failed — mark as failed
+                this.update((state) => {
+                    state.initializationState = InitializationState.Failed;
+                });
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(reinitError, 'PerpsController.switchProvider.rollback'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'switchProvider.rollback', {
+                    previousProvider,
+                }));
+            }
+            return {
+                success: false,
+                providerId: previousProvider,
+                error: error instanceof Error
+                    ? error.message
+                    : PERPS_ERROR_CODES.UNKNOWN_ERROR,
+            };
+        }
+        finally {
+            __classPrivateFieldSet(this, _PerpsController_isReinitializing, false, "f");
+        }
+    }
+    /**
+     * Get current network (mainnet/testnet)
+     *
+     * @returns Either 'mainnet' or 'testnet' based on the current configuration.
+     */
+    getCurrentNetwork() {
+        return this.state.isTestnet ? 'testnet' : 'mainnet';
+    }
+    /**
+     * Get the current WebSocket connection state from the active provider.
+     * Used by the UI to monitor connection health and show notifications.
+     *
+     * @returns The current WebSocket connection state, or DISCONNECTED if not supported
+     */
+    getWebSocketConnectionState() {
+        try {
+            const provider = this.getActiveProvider();
+            if (provider.getWebSocketConnectionState) {
+                return provider.getWebSocketConnectionState();
+            }
+            // Fallback for providers that don't support this method
+            return WebSocketConnectionState.Disconnected;
+        }
+        catch {
+            // If no provider is active, return disconnected
+            return WebSocketConnectionState.Disconnected;
+        }
+    }
+    /**
+     * Subscribe to WebSocket connection state changes from the active provider.
+     * The listener will be called immediately with the current state and whenever the state changes.
+     *
+     * @param listener - Callback function that receives the new connection state and reconnection attempt
+     * @returns Unsubscribe function to remove the listener, or no-op if not supported
+     */
+    subscribeToConnectionState(listener) {
+        try {
+            const provider = this.getActiveProvider();
+            if (provider.subscribeToConnectionState) {
+                return provider.subscribeToConnectionState(listener);
+            }
+            // Fallback: immediately call with current state and return no-op unsubscribe
+            listener(this.getWebSocketConnectionState(), 0);
+            return () => {
+                // No-op
+            };
+        }
+        catch {
+            // If no provider is active, call with disconnected and return no-op
+            listener(WebSocketConnectionState.Disconnected, 0);
+            return () => {
+                // No-op
+            };
+        }
+    }
+    /**
+     * Manually trigger a WebSocket reconnection attempt.
+     * Used by the UI retry button when connection is lost.
+     */
+    async reconnect() {
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, '[PerpsController] reconnect() called');
+        try {
+            const provider = this.getActiveProvider();
+            if (provider.reconnect) {
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, '[PerpsController] Delegating to provider.reconnect()');
+                await provider.reconnect();
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, '[PerpsController] provider.reconnect() completed');
+            }
+            else {
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, '[PerpsController] Provider does not support reconnect()');
+            }
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.reconnect'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'reconnect', {
+                operation: 'websocket_reconnect',
+            }));
+        }
+    }
+    // Live data delegation (NO Redux) - delegates to active provider
+    /**
+     * Subscribe to live price updates
+     *
+     * @param params - The operation parameters.
+     * @returns A cleanup function to remove the subscription.
+     */
+    subscribeToPrices(params) {
+        const provider = this.getActiveProviderOrNull();
+        if (!provider) {
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+        try {
+            return provider.subscribeToPrices(params);
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.subscribeToPrices'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'subscribeToPrices', {
+                symbols: params.symbols?.join(','),
+            }));
+            return () => {
+                // No-op
+            };
+        }
+    }
+    /**
+     * Subscribe to live position updates
+     *
+     * @param params - The operation parameters.
+     * @returns A cleanup function to remove the subscription.
+     */
+    subscribeToPositions(params) {
+        const provider = this.getActiveProviderOrNull();
+        if (!provider) {
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+        try {
+            return provider.subscribeToPositions(params);
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.subscribeToPositions'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'subscribeToPositions', {
+                accountId: params.accountId,
+            }));
+            return () => {
+                // No-op
+            };
+        }
+    }
+    /**
+     * Subscribe to live order fill updates
+     *
+     * @param params - The operation parameters.
+     * @returns A cleanup function to remove the subscription.
+     */
+    subscribeToOrderFills(params) {
+        const provider = this.getActiveProviderOrNull();
+        if (!provider) {
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+        try {
+            return provider.subscribeToOrderFills(params);
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.subscribeToOrderFills'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'subscribeToOrderFills', {
+                accountId: params.accountId,
+            }));
+            return () => {
+                // No-op
+            };
+        }
+    }
+    /**
+     * Subscribe to live order updates
+     *
+     * @param params - The operation parameters.
+     * @returns A cleanup function to remove the subscription.
+     */
+    subscribeToOrders(params) {
+        const provider = this.getActiveProviderOrNull();
+        if (!provider) {
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+        try {
+            return provider.subscribeToOrders(params);
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.subscribeToOrders'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'subscribeToOrders', {
+                accountId: params.accountId,
+            }));
+            return () => {
+                // No-op
+            };
+        }
+    }
+    /**
+     * Subscribe to live account updates.
+     * Updates controller state (Redux) when new account data arrives so consumers
+     * like usePerpsBalanceTokenFilter (PayWithModal) see the latest balance.
+     *
+     * @param params - The operation parameters.
+     * @returns A cleanup function to remove the subscription.
+     */
+    subscribeToAccount(params) {
+        const provider = this.getActiveProviderOrNull();
+        if (!provider) {
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+        try {
+            const originalCallback = params.callback;
+            return provider.subscribeToAccount({
+                ...params,
+                callback: (account) => {
+                    if (account) {
+                        this.update((state) => {
+                            state.accountState = account;
+                            state.lastUpdateTimestamp = Date.now();
+                            state.lastError = null;
+                        });
+                    }
+                    originalCallback(account);
+                },
+            });
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.subscribeToAccount'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'subscribeToAccount', {
+                accountId: params.accountId,
+            }));
+            return () => {
+                // No-op
+            };
+        }
+    }
+    /**
+     * Subscribe to full order book updates with multiple depth levels
+     * Creates a dedicated L2Book subscription for real-time order book data
+     *
+     * @param params - The operation parameters.
+     * @returns A cleanup function to remove the subscription.
+     */
+    subscribeToOrderBook(params) {
+        const provider = this.getActiveProviderOrNull();
+        if (!provider) {
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+        try {
+            return provider.subscribeToOrderBook(params);
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.subscribeToOrderBook'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'subscribeToOrderBook', {
+                symbol: params.symbol,
+                levels: params.levels,
+            }));
+            return () => {
+                // No-op
+            };
+        }
+    }
+    /**
+     * Subscribe to live candle updates
+     *
+     * @param params - The operation parameters.
+     * @returns A cleanup function to remove the subscription.
+     */
+    subscribeToCandles(params) {
+        const provider = this.getActiveProviderOrNull();
+        if (!provider) {
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+        try {
+            return provider.subscribeToCandles(params);
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.subscribeToCandles'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'subscribeToCandles', {
+                symbol: params.symbol,
+                interval: params.interval,
+                duration: params.duration,
+            }));
+            return () => {
+                // No-op
+            };
+        }
+    }
+    /**
+     * Subscribe to open interest cap updates
+     * Zero additional network overhead - data comes from existing webData3 subscription
+     *
+     * @param params - The operation parameters.
+     * @returns A cleanup function to remove the subscription.
+     */
+    subscribeToOICaps(params) {
+        const provider = this.getActiveProviderOrNull();
+        if (!provider) {
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+        try {
+            return provider.subscribeToOICaps(params);
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.subscribeToOICaps'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'subscribeToOICaps', {
+                accountId: params.accountId,
+            }));
+            return () => {
+                // No-op
+            };
+        }
+    }
+    /**
+     * Configure live data throttling
+     *
+     * @param config - The configuration object.
+     */
+    setLiveDataConfig(config) {
+        try {
+            const provider = this.getActiveProvider();
+            provider.setLiveDataConfig(config);
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.setLiveDataConfig'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'setLiveDataConfig'));
+        }
+    }
+    /**
+     * Calculate trading fees for the active provider
+     * Each provider implements its own fee structure
+     *
+     * @param params - The operation parameters.
+     * @returns The fee calculation result for the trade.
+     */
+    async calculateFees(params) {
+        const provider = this.getActiveProvider();
+        const context = __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'calculateFees');
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").calculateFees({ provider, params, context });
+    }
+    /**
+     * Disconnect provider and cleanup subscriptions
+     * Call this when navigating away from Perps screens to prevent battery drain
+     */
+    async disconnect() {
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Disconnecting provider to cleanup subscriptions', {
+            timestamp: new Date().toISOString(),
+        });
+        // Stop preload interval and messenger subscriptions first,
+        // so no background work fires while we tear down providers.
+        if (__classPrivateFieldGet(this, _PerpsController_preloadTimer, "f")) {
+            clearInterval(__classPrivateFieldGet(this, _PerpsController_preloadTimer, "f"));
+            __classPrivateFieldSet(this, _PerpsController_preloadTimer, null, "f");
+        }
+        if (__classPrivateFieldGet(this, _PerpsController_preloadStateUnsubscribe, "f")) {
+            __classPrivateFieldGet(this, _PerpsController_preloadStateUnsubscribe, "f").call(this);
+            __classPrivateFieldSet(this, _PerpsController_preloadStateUnsubscribe, null, "f");
+        }
+        if (__classPrivateFieldGet(this, _PerpsController_accountChangeUnsubscribe, "f")) {
+            __classPrivateFieldGet(this, _PerpsController_accountChangeUnsubscribe, "f").call(this);
+            __classPrivateFieldSet(this, _PerpsController_accountChangeUnsubscribe, null, "f");
+        }
+        __classPrivateFieldSet(this, _PerpsController_previousIsTestnet, null, "f");
+        __classPrivateFieldSet(this, _PerpsController_previousHip3ConfigVersion, null, "f");
+        // Only disconnect the provider if we're initialized
+        if (this.isInitialized && !this.isCurrentlyReinitializing()) {
+            try {
+                const provider = this.getActiveProvider();
+                await provider.disconnect();
+            }
+            catch (error) {
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.disconnect'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'disconnect'));
+            }
+        }
+        // Clear stale reference so standalone reads don't route through old provider
+        this.activeProviderInstance = null;
+        // Cleanup cached standalone provider (if any) — awaited to prevent races
+        await __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_cleanupStandaloneProvider).call(this);
+        // Note: Feature-flag subscription is NOT cleaned up here.
+        // It is a controller-lifetime concern (set once in the constructor),
+        // not a session-lifetime concern. Unsubscribing here would break
+        // geo-blocking / HIP-3 flag propagation after disconnect → reconnect.
+        // Reset initialization state to ensure proper reconnection
+        this.isInitialized = false;
+        __classPrivateFieldSet(this, _PerpsController_initializationPromise, null, "f");
+    }
+    /**
+     * Eligibility (Geo-Blocking)
+     */
+    /**
+     * Fetch geo location
+     *
+     * Returned in Country or Country-Region format
+     * Example: FR, DE, US-MI, CA-ON
+     */
+    /**
+     * Refresh eligibility status
+     */
+    async refreshEligibility() {
+        // Capture the current version before starting the async operation.
+        // This prevents race conditions where stale eligibility checks
+        // (started with fallback config) overwrite results from newer checks
+        // (started with remote config after it was fetched).
+        const versionAtStart = __classPrivateFieldGet(this, _PerpsController_blockedRegionListVersion, "f");
+        try {
+            // TODO: It would be good to have this location before we call this async function to avoid the race condition
+            const isEligible = await __classPrivateFieldGet(this, _PerpsController_eligibilityService, "f").checkEligibility({
+                blockedRegions: this.blockedRegionList.list,
+            });
+            // Only update state if the blocked region list hasn't changed while we were awaiting.
+            // This prevents stale fallback-based eligibility checks from overwriting
+            // results from remote-based checks.
+            if (__classPrivateFieldGet(this, _PerpsController_blockedRegionListVersion, "f") !== versionAtStart) {
+                return;
+            }
+            this.update((state) => {
+                state.isEligible = isEligible;
+            });
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.refreshEligibility'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'refreshEligibility'));
+            // Only update on error if version is still current
+            if (__classPrivateFieldGet(this, _PerpsController_blockedRegionListVersion, "f") === versionAtStart) {
+                // Default to eligible on error
+                this.update((state) => {
+                    state.isEligible = true;
+                });
+            }
+        }
+    }
+    /**
+     * Get block explorer URL for an address or just the base URL
+     *
+     * @param address - Optional address to append to the base URL
+     * @returns Block explorer URL
+     */
+    getBlockExplorerUrl(address) {
+        const provider = this.getActiveProvider();
+        return __classPrivateFieldGet(this, _PerpsController_marketDataService, "f").getBlockExplorerUrl({ provider, address });
+    }
+    /**
+     * Check if user is first-time for the current network
+     *
+     * @returns True if the condition is met.
+     */
+    isFirstTimeUserOnCurrentNetwork() {
+        const currentNetwork = this.state.isTestnet ? 'testnet' : 'mainnet';
+        return this.state.isFirstTimeUser[currentNetwork];
+    }
+    /**
+     * Mark that the user has completed the tutorial/onboarding
+     * This prevents the tutorial from showing again
+     */
+    markTutorialCompleted() {
+        const currentNetwork = this.state.isTestnet ? 'testnet' : 'mainnet';
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Marking tutorial as completed', {
+            timestamp: new Date().toISOString(),
+            network: currentNetwork,
+        });
+        this.update((state) => {
+            state.isFirstTimeUser[currentNetwork] = false;
+        });
+    }
+    /*
+     * Mark that user has placed their first successful order
+     * This prevents the notification tooltip from showing again
+     */
+    markFirstOrderCompleted() {
+        const currentNetwork = this.state.isTestnet ? 'testnet' : 'mainnet';
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Marking first order completed', {
+            timestamp: new Date().toISOString(),
+            network: currentNetwork,
+        });
+        this.update((state) => {
+            state.hasPlacedFirstOrder[currentNetwork] = true;
+        });
+    }
+    /**
+     * Reset first-time user state for both networks
+     * This is useful for testing the tutorial flow
+     * Called by Reset Account feature in settings
+     */
+    resetFirstTimeUserState() {
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Resetting first-time user state', {
+            timestamp: new Date().toISOString(),
+            previousState: this.state.isFirstTimeUser,
+        });
+        this.update((state) => {
+            state.isFirstTimeUser = {
+                testnet: true,
+                mainnet: true,
+            };
+            state.hasPlacedFirstOrder = {
+                testnet: false,
+                mainnet: false,
+            };
+        });
+    }
+    /**
+     * Clear pending/bridging withdrawal and deposit requests
+     * This is useful when users want to clear stuck pending indicators
+     * Called by Reset Account feature in settings
+     */
+    clearPendingTransactionRequests() {
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Clearing pending transaction requests', {
+            timestamp: new Date().toISOString(),
+        });
+        this.update((state) => {
+            // Filter out pending/bridging withdrawals, keep completed/failed for history
+            state.withdrawalRequests = state.withdrawalRequests.filter((req) => req.status !== 'pending' && req.status !== 'bridging');
+            // Filter out pending deposits, keep completed/failed for history
+            state.depositRequests = state.depositRequests.filter((req) => req.status !== 'pending' && req.status !== 'bridging');
+            // Reset withdrawal progress
+            state.withdrawalProgress = {
+                progress: 0,
+                lastUpdated: Date.now(),
+                activeWithdrawalId: null,
+            };
+        });
+    }
+    /**
+     * Get saved trade configuration for a market
+     *
+     * @param symbol - The trading pair symbol.
+     * @returns The resulting string value.
+     */
+    getTradeConfiguration(symbol) {
+        const network = this.state.isTestnet ? 'testnet' : 'mainnet';
+        const config = this.state.tradeConfigurations[network]?.[symbol];
+        if (!config?.leverage) {
+            return undefined;
+        }
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Retrieved trade config', {
+            symbol,
+            network,
+            leverage: config.leverage,
+        });
+        return { leverage: config.leverage };
+    }
+    /**
+     * Save trade configuration for a market
+     *
+     * @param symbol - Market symbol
+     * @param leverage - Leverage value
+     */
+    saveTradeConfiguration(symbol, leverage) {
+        const network = this.state.isTestnet ? 'testnet' : 'mainnet';
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Saving trade configuration', {
+            symbol,
+            network,
+            leverage,
+            timestamp: new Date().toISOString(),
+        });
+        this.update((state) => {
+            if (!state.tradeConfigurations[network]) {
+                state.tradeConfigurations[network] = {};
+            }
+            const existingConfig = state.tradeConfigurations[network][symbol] || {};
+            state.tradeConfigurations[network][symbol] = {
+                ...existingConfig,
+                leverage,
+            };
+        });
+    }
+    /**
+     * Save pending trade configuration for a market
+     * This is a temporary configuration that expires after 5 minutes
+     *
+     * @param symbol - Market symbol
+     * @param config - Pending trade configuration (includes optional selected payment token from Pay row)
+     * @param config.amount - The amount value.
+     * @param config.leverage - The leverage multiplier.
+     * @param config.takeProfitPrice - The take profit price.
+     * @param config.stopLossPrice - The stop loss price.
+     * @param config.limitPrice - The limit price.
+     * @param config.orderType - The order type.
+     * @param config.selectedPaymentToken - The selected payment token.
+     */
+    savePendingTradeConfiguration(symbol, config) {
+        const network = this.state.isTestnet ? 'testnet' : 'mainnet';
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Saving pending trade configuration', {
+            symbol,
+            network,
+            config,
+            timestamp: new Date().toISOString(),
+        });
+        this.update((state) => {
+            if (!state.tradeConfigurations[network]) {
+                state.tradeConfigurations[network] = {};
+            }
+            const existingConfig = state.tradeConfigurations[network][symbol] || {};
+            state.tradeConfigurations[network][symbol] = {
+                ...existingConfig,
+                pendingConfig: {
+                    ...config,
+                    timestamp: Date.now(),
+                },
+            };
+        });
+    }
+    /**
+     * Get pending trade configuration for a market
+     * Returns undefined if config doesn't exist or has expired (more than 5 minutes old)
+     *
+     * @param symbol - Market symbol
+     * @returns Pending trade configuration or undefined
+     */
+    getPendingTradeConfiguration(symbol) {
+        const network = this.state.isTestnet ? 'testnet' : 'mainnet';
+        const config = this.state.tradeConfigurations[network]?.[symbol]?.pendingConfig;
+        if (!config) {
+            return undefined;
+        }
+        // Check if config has expired (5 minutes = 300,000 milliseconds)
+        const FIVE_MINUTES_MS = 5 * 60 * 1000;
+        const now = Date.now();
+        const age = now - config.timestamp;
+        if (age > FIVE_MINUTES_MS) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Pending trade config expired', {
+                symbol,
+                network,
+                age,
+                timestamp: config.timestamp,
+            });
+            // Clear expired config
+            this.update((state) => {
+                if (state.tradeConfigurations[network]?.[symbol]?.pendingConfig) {
+                    delete state.tradeConfigurations[network][symbol].pendingConfig;
+                }
+            });
+            return undefined;
+        }
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Retrieved pending trade config', {
+            symbol,
+            network,
+            config,
+            age,
+        });
+        // Return config without timestamp
+        const { timestamp, ...configWithoutTimestamp } = config;
+        return configWithoutTimestamp;
+    }
+    /**
+     * Clear pending trade configuration for a market
+     *
+     * @param symbol - Market symbol
+     */
+    clearPendingTradeConfiguration(symbol) {
+        const network = this.state.isTestnet ? 'testnet' : 'mainnet';
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Clearing pending trade configuration', {
+            symbol,
+            network,
+            timestamp: new Date().toISOString(),
+        });
+        this.update((state) => {
+            if (state.tradeConfigurations[network]?.[symbol]?.pendingConfig) {
+                delete state.tradeConfigurations[network][symbol].pendingConfig;
+            }
+        });
+    }
+    /**
+     * Get saved market filter preferences
+     * Handles backward compatibility with legacy string format
+     *
+     * @returns The saved sort option ID and direction.
+     */
+    getMarketFilterPreferences() {
+        const pref = this.state.marketFilterPreferences;
+        // Handle legacy string format (backward compatibility)
+        if (typeof pref === 'string') {
+            // Map legacy compound IDs to new format
+            // Old format: 'priceChange-desc' or 'priceChange-asc'
+            // New format: { optionId: 'priceChange', direction: 'desc'/'asc' }
+            if (pref === 'priceChange-desc') {
+                return {
+                    optionId: 'priceChange',
+                    direction: 'desc',
+                };
+            }
+            if (pref === 'priceChange-asc') {
+                return {
+                    optionId: 'priceChange',
+                    direction: 'asc',
+                };
+            }
+            // Handle other simple legacy strings (e.g., 'volume', 'openInterest', etc.)
+            return {
+                optionId: pref,
+                direction: MARKET_SORTING_CONFIG.DefaultDirection,
+            };
+        }
+        // Return new object format or default
+        return (pref ?? {
+            optionId: MARKET_SORTING_CONFIG.DefaultSortOptionId,
+            direction: MARKET_SORTING_CONFIG.DefaultDirection,
+        });
+    }
+    /**
+     * Save market filter preferences
+     *
+     * @param optionId - Sort/filter option ID
+     * @param direction - Sort direction ('asc' or 'desc')
+     */
+    saveMarketFilterPreferences(optionId, direction) {
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Saving market filter preferences', {
+            optionId,
+            direction,
+            timestamp: new Date().toISOString(),
+        });
+        this.update((state) => {
+            state.marketFilterPreferences = { optionId, direction };
+        });
+    }
+    /**
+     * Set the selected payment token for the Perps order/deposit flow.
+     * Pass null or a token with description PERPS_CONSTANTS.PerpsBalanceTokenDescription to select Perps balance.
+     * Only required fields (address, chainId) are stored in state; description and symbol are optional.
+     *
+     * @param token - The token identifier.
+     */
+    setSelectedPaymentToken(token) {
+        let normalized = null;
+        if (token !== null &&
+            token.description !== PERPS_CONSTANTS.PerpsBalanceTokenDescription) {
+            normalized = token;
+        }
+        const current = this.state.selectedPaymentToken;
+        const initialPaymentMethod = current === null ||
+            current === undefined ||
+            current?.description === PERPS_CONSTANTS.PerpsBalanceTokenDescription
+            ? 'perps_balance'
+            : (current?.symbol ?? 'unknown');
+        const newPaymentMethod = token === null ||
+            token.description === PERPS_CONSTANTS.PerpsBalanceTokenDescription
+            ? 'perps_balance'
+            : (token.symbol ?? 'unknown');
+        if (initialPaymentMethod !== newPaymentMethod) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getMetrics).call(this).trackPerpsEvent(PerpsAnalyticsEvent.UiInteraction, {
+                [PERPS_EVENT_PROPERTY.INTERACTION_TYPE]: PERPS_EVENT_VALUE.INTERACTION_TYPE.PAYMENT_METHOD_CHANGED,
+                [PERPS_EVENT_PROPERTY.INITIAL_PAYMENT_METHOD]: initialPaymentMethod,
+                [PERPS_EVENT_PROPERTY.NEW_PAYMENT_METHOD]: newPaymentMethod,
+            });
+        }
+        let snapshot = null;
+        if (normalized !== null) {
+            snapshot = {
+                ...(normalized.description !== undefined && {
+                    description: normalized.description,
+                }),
+                address: normalized.address,
+                chainId: normalized.chainId,
+                symbol: normalized.symbol,
+            };
+        }
+        this.update((state) => {
+            state.selectedPaymentToken = snapshot;
+        });
+    }
+    /**
+     * Reset the selected payment token to Perps balance (null).
+     * Call when leaving the Perps order view so the next visit defaults to Perps balance.
+     */
+    resetSelectedPaymentToken() {
+        this.update((state) => {
+            state.selectedPaymentToken = null;
+        });
+    }
+    /**
+     * Get saved order book grouping for a market
+     *
+     * @param symbol - Market symbol
+     * @returns The saved grouping value or undefined if not set
+     */
+    getOrderBookGrouping(symbol) {
+        const network = this.state.isTestnet ? 'testnet' : 'mainnet';
+        const grouping = this.state.tradeConfigurations[network]?.[symbol]?.orderBookGrouping;
+        if (grouping !== undefined) {
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Retrieved order book grouping', {
+                symbol,
+                network,
+                grouping,
+            });
+        }
+        return grouping;
+    }
+    /**
+     * Save order book grouping for a market
+     *
+     * @param symbol - Market symbol
+     * @param grouping - Price grouping value
+     */
+    saveOrderBookGrouping(symbol, grouping) {
+        const network = this.state.isTestnet ? 'testnet' : 'mainnet';
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Saving order book grouping', {
+            symbol,
+            network,
+            grouping,
+            timestamp: new Date().toISOString(),
+        });
+        this.update((state) => {
+            if (!state.tradeConfigurations[network]) {
+                state.tradeConfigurations[network] = {};
+            }
+            const existingConfig = state.tradeConfigurations[network][symbol] || {};
+            state.tradeConfigurations[network][symbol] = {
+                ...existingConfig,
+                orderBookGrouping: grouping,
+            };
+        });
+    }
+    /**
+     * Toggle watchlist status for a market
+     * Watchlist markets are stored per network (testnet/mainnet)
+     *
+     * @param symbol - The trading pair symbol.
+     */
+    toggleWatchlistMarket(symbol) {
+        const currentNetwork = this.state.isTestnet ? 'testnet' : 'mainnet';
+        const currentWatchlist = this.state.watchlistMarkets[currentNetwork];
+        const isWatchlisted = currentWatchlist.includes(symbol);
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Toggling watchlist market', {
+            timestamp: new Date().toISOString(),
+            network: currentNetwork,
+            symbol,
+            action: isWatchlisted ? 'remove' : 'add',
+        });
+        this.update((state) => {
+            if (isWatchlisted) {
+                // Remove from watchlist
+                state.watchlistMarkets[currentNetwork] = currentWatchlist.filter((marketSymbol) => marketSymbol !== symbol);
+            }
+            else {
+                // Add to watchlist
+                state.watchlistMarkets[currentNetwork] = [...currentWatchlist, symbol];
+            }
+        });
+    }
+    /**
+     * Check if a market is in the watchlist on the current network
+     *
+     * @param symbol - The trading pair symbol.
+     * @returns True if the condition is met.
+     */
+    isWatchlistMarket(symbol) {
+        const currentNetwork = this.state.isTestnet ? 'testnet' : 'mainnet';
+        return this.state.watchlistMarkets[currentNetwork].includes(symbol);
+    }
+    /**
+     * Get all watchlist markets for the current network
+     *
+     * @returns The resulting string value.
+     */
+    getWatchlistMarkets() {
+        const currentNetwork = this.state.isTestnet ? 'testnet' : 'mainnet';
+        return this.state.watchlistMarkets[currentNetwork];
+    }
+    /**
+     * Report order events to data lake API with retry (non-blocking)
+     * Thin delegation to DataLakeService
+     *
+     * @param params - The operation parameters.
+     * @param params.action - The order action.
+     * @param params.symbol - The trading pair symbol.
+     * @param params.slPrice - The stop loss price.
+     * @param params.tpPrice - The take profit price.
+     * @param params.retryCount - Internal retry counter.
+     * @param params._traceId - Internal trace ID.
+     * @returns Whether the report was sent successfully, with an optional error message.
+     */
+    async reportOrderToDataLake(params) {
+        return __classPrivateFieldGet(this, _PerpsController_dataLakeService, "f").reportOrder({
+            action: params.action,
+            symbol: params.symbol,
+            slPrice: params.slPrice,
+            tpPrice: params.tpPrice,
+            isTestnet: this.state.isTestnet,
+            context: __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_createServiceContext).call(this, 'reportOrderToDataLake', {}),
+            retryCount: params.retryCount,
+            _traceId: params._traceId,
+        });
+    }
+    /**
+     * Check if the controller is currently reinitializing
+     *
+     * @returns true if providers are being reinitialized
+     */
+    isCurrentlyReinitializing() {
+        return __classPrivateFieldGet(this, _PerpsController_isReinitializing, "f");
+    }
 }
+_a = PerpsController, _PerpsController_initializationPromise = new WeakMap(), _PerpsController_isReinitializing = new WeakMap(), _PerpsController_blockedRegionListVersion = new WeakMap(), _PerpsController_hip3Enabled = new WeakMap(), _PerpsController_hip3AllowlistMarkets = new WeakMap(), _PerpsController_hip3BlocklistMarkets = new WeakMap(), _PerpsController_hip3ConfigSource = new WeakMap(), _PerpsController_standaloneProvider = new WeakMap(), _PerpsController_standaloneProviderIsTestnet = new WeakMap(), _PerpsController_standaloneProviderHip3Version = new WeakMap(), _PerpsController_options = new WeakMap(), _PerpsController_tradingService = new WeakMap(), _PerpsController_marketDataService = new WeakMap(), _PerpsController_accountService = new WeakMap(), _PerpsController_eligibilityService = new WeakMap(), _PerpsController_dataLakeService = new WeakMap(), _PerpsController_depositService = new WeakMap(), _PerpsController_featureFlagConfigurationService = new WeakMap(), _PerpsController_rewardsIntegrationService = new WeakMap(), _PerpsController_preloadTimer = new WeakMap(), _PerpsController_isPreloading = new WeakMap(), _PerpsController_isPreloadingUserData = new WeakMap(), _PerpsController_preloadStateUnsubscribe = new WeakMap(), _PerpsController_accountChangeUnsubscribe = new WeakMap(), _PerpsController_previousIsTestnet = new WeakMap(), _PerpsController_previousHip3ConfigVersion = new WeakMap(), _PerpsController_instances = new WeakSet(), _PerpsController_isMYXProviderEnabled = function _PerpsController_isMYXProviderEnabled() {
+    const getLocalFlag = () => typeof globalThis.process !== 'undefined' &&
+        globalThis.process.env?.MM_PERPS_MYX_PROVIDER_ENABLED === 'true';
+    try {
+        const localFlag = getLocalFlag();
+        const remoteState = this.messenger.call('RemoteFeatureFlagController:getState');
+        const remoteFlag = remoteState.remoteFeatureFlags?.perpsMyxProviderEnabled;
+        if (isVersionGatedFeatureFlag(remoteFlag)) {
+            const validated = __classPrivateFieldGet(this, _PerpsController_options, "f").infrastructure.featureFlags.validateVersionGated(remoteFlag);
+            return validated ?? localFlag;
+        }
+        return localFlag;
+    }
+    catch {
+        // If RemoteFeatureFlagController not ready, use fallback
+        return getLocalFlag();
+    }
+}, _PerpsController_logError = function _PerpsController_logError(error, options) {
+    __classPrivateFieldGet(this, _PerpsController_options, "f").infrastructure.logger.error(error, options);
+}, _PerpsController_debugLog = function _PerpsController_debugLog(...args) {
+    __classPrivateFieldGet(this, _PerpsController_options, "f").infrastructure.debugLogger.log(...args);
+}, _PerpsController_getOrCreateStandaloneProvider = function _PerpsController_getOrCreateStandaloneProvider() {
+    const currentIsTestnet = this.state.isTestnet;
+    const currentHip3Version = this.state.hip3ConfigVersion ?? 0;
+    if (__classPrivateFieldGet(this, _PerpsController_standaloneProvider, "f") &&
+        __classPrivateFieldGet(this, _PerpsController_standaloneProviderIsTestnet, "f") === currentIsTestnet &&
+        __classPrivateFieldGet(this, _PerpsController_standaloneProviderHip3Version, "f") === currentHip3Version) {
+        return __classPrivateFieldGet(this, _PerpsController_standaloneProvider, "f");
+    }
+    // Stale or missing — tear down old one (fire-and-forget)
+    if (__classPrivateFieldGet(this, _PerpsController_standaloneProvider, "f")) {
+        const old = __classPrivateFieldGet(this, _PerpsController_standaloneProvider, "f");
+        Promise.resolve(old.disconnect()).catch(() => {
+            /* best-effort */
+        });
+    }
+    __classPrivateFieldSet(this, _PerpsController_standaloneProvider, new HyperLiquidProvider({
+        isTestnet: currentIsTestnet,
+        hip3Enabled: __classPrivateFieldGet(this, _PerpsController_hip3Enabled, "f"),
+        allowlistMarkets: __classPrivateFieldGet(this, _PerpsController_hip3AllowlistMarkets, "f"),
+        blocklistMarkets: __classPrivateFieldGet(this, _PerpsController_hip3BlocklistMarkets, "f"),
+        platformDependencies: __classPrivateFieldGet(this, _PerpsController_options, "f").infrastructure,
+        messenger: this.messenger,
+    }), "f");
+    __classPrivateFieldSet(this, _PerpsController_standaloneProviderIsTestnet, currentIsTestnet, "f");
+    __classPrivateFieldSet(this, _PerpsController_standaloneProviderHip3Version, currentHip3Version, "f");
+    return __classPrivateFieldGet(this, _PerpsController_standaloneProvider, "f");
+}, _PerpsController_cleanupStandaloneProvider = 
 /**
- * `PerpsController` manages perpetual trading functionality in MetaMask.
- *
- * This controller provides platform-agnostic perps trading capabilities.
+ * Disconnect and discard the cached standalone provider (if any).
+ * Best-effort — errors are silently caught.
+ */
+async function _PerpsController_cleanupStandaloneProvider() {
+    if (!__classPrivateFieldGet(this, _PerpsController_standaloneProvider, "f")) {
+        return;
+    }
+    try {
+        await __classPrivateFieldGet(this, _PerpsController_standaloneProvider, "f").disconnect();
+    }
+    catch {
+        /* best-effort */
+    }
+    __classPrivateFieldSet(this, _PerpsController_standaloneProvider, null, "f");
+    __classPrivateFieldSet(this, _PerpsController_standaloneProviderIsTestnet, null, "f");
+    __classPrivateFieldSet(this, _PerpsController_standaloneProviderHip3Version, null, "f");
+}, _PerpsController_getMetrics = function _PerpsController_getMetrics() {
+    return __classPrivateFieldGet(this, _PerpsController_options, "f").infrastructure.metrics;
+}, _PerpsController_findNetworkClientIdForChain = function _PerpsController_findNetworkClientIdForChain(chainId) {
+    return this.messenger.call('NetworkController:findNetworkClientIdByChainId', chainId);
+}, _PerpsController_submitTransaction = 
+/**
+ * Submit a transaction via messenger (shows confirmation screen)
  *
- * @example
+ * @param txParams - The transaction parameters.
+ * @param txParams.from - The sender address.
+ * @param txParams.to - The recipient address.
+ * @param txParams.value - The transaction value.
+ * @param txParams.data - The transaction data payload.
+ * @param txParams.gas - The gas limit.
+ * @param options - The configuration options.
+ * @param options.networkClientId - The network client identifier.
+ * @param options.origin - The transaction origin.
+ * @param options.type - The transaction type.
+ * @param options.skipInitialGasEstimate - Whether to skip initial gas estimation.
+ * @returns The transaction result containing a hash promise and transaction metadata.
+ */
+async function _PerpsController_submitTransaction(txParams, options) {
+    // Cast needed: PerpsController uses loose string types for txParams/options
+    // while TransactionController uses strict branded types (TransactionParams, AddTransactionOptions)
+    return this.messenger.call('TransactionController:addTransaction', 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    txParams, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    options);
+}, _PerpsController_migrateRequestsIfNeeded = function _PerpsController_migrateRequestsIfNeeded() {
+    this.update((state) => {
+        // Remove withdrawal requests without accountAddress - they can't be attributed to any account
+        state.withdrawalRequests = state.withdrawalRequests.filter((req) => Boolean(req.accountAddress));
+        // Remove deposit requests without accountAddress - they can't be attributed to any account
+        state.depositRequests = state.depositRequests.filter((req) => Boolean(req.accountAddress));
+    });
+}, _PerpsController_withStreamPause = 
+/**
+ * Execute an operation while temporarily pausing specified stream channels
+ * to prevent WebSocket updates from triggering UI re-renders during operations.
  *
- * ``` ts
- * import { Messenger } from '@metamask/messenger';
- * import type {
- *   PerpsControllerActions,
- *   PerpsControllerEvents,
- * } from '@metamask/perps-controller';
- * import { PerpsController } from '@metamask/perps-controller';
+ * WebSocket connections remain alive but updates are not emitted to subscribers.
+ * This prevents race conditions where UI re-renders fetch stale data during operations.
  *
- * const rootMessenger = new Messenger<
- *   'Root',
- *   PerpsControllerActions,
- *   PerpsControllerEvents
- * >({ namespace: 'Root' });
- * const perpsControllerMessenger = new Messenger<
- *   'PerpsController',
- *   PerpsControllerActions,
- *   PerpsControllerEvents,
- *   typeof rootMessenger,
- * >({
- *   namespace: 'PerpsController',
- *   parent: rootMessenger,
- * });
- * // Instantiate the controller to register its actions on the messenger
- * new PerpsController({
- *   messenger: perpsControllerMessenger,
- * });
+ * @param operation - The async operation to execute
+ * @param channels - Array of stream channel names to pause
+ * @returns The result of the operation
+ * @example
+ * ```typescript
+ * // Cancel orders without stream interference
+ * await this.#withStreamPause(
+ *   async () => this.provider.cancelOrders({ cancelAll: true }),
+ *   ['orders']
+ * );
  *
- * const perpsControllerState = await rootMessenger.call(
- *   'PerpsController:getState',
+ * // Close positions and pause multiple streams
+ * await this.#withStreamPause(
+ *   async () => this.provider.closePositions(positions),
+ *   ['positions', 'account', 'orders']
  * );
  * ```
  */
-export class PerpsController extends BaseController {
-    /**
-     * Constructs a new {@link PerpsController}.
-     *
-     * @param args - The arguments to this controller.
-     * @param args.messenger - The messenger suited for this controller.
-     * @param args.state - The desired state with which to initialize this
-     * controller. Missing properties will be filled in with defaults.
-     */
-    constructor({ messenger, state, }) {
-        super({
-            messenger,
-            metadata: perpsControllerMetadata,
-            name: controllerName,
-            state: {
-                ...getDefaultPerpsControllerState(),
-                ...state,
+async function _PerpsController_withStreamPause(operation, channels) {
+    const pausedChannels = [];
+    const { streamManager } = __classPrivateFieldGet(this, _PerpsController_options, "f").infrastructure;
+    // Pause emission on specified channels (WebSocket stays connected)
+    // Track which channels successfully paused to ensure proper cleanup
+    for (const channel of channels) {
+        try {
+            streamManager.pauseChannel(channel);
+            pausedChannels.push(channel);
+        }
+        catch (error) {
+            // Log error to Sentry but continue pausing remaining channels
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.withStreamPause'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'withStreamPause', {
+                operation: 'pause',
+                channel: String(channel),
+                pausedChannels: pausedChannels.join(','),
+            }));
+        }
+    }
+    try {
+        // Execute operation without stream interference
+        return await operation();
+    }
+    finally {
+        // Resume only channels that were successfully paused
+        for (const channel of pausedChannels) {
+            try {
+                streamManager.resumeChannel(channel);
+            }
+            catch (error) {
+                // Log error to Sentry but continue resuming remaining channels
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.withStreamPause'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'withStreamPause', {
+                    operation: 'resume',
+                    channel: String(channel),
+                    pausedChannels: pausedChannels.join(','),
+                }));
+            }
+        }
+    }
+}, _PerpsController_performInitialization = 
+/**
+ * Actual initialization implementation with retry logic
+ */
+async function _PerpsController_performInitialization() {
+    const maxAttempts = 3;
+    const baseDelay = 1000;
+    this.update((state) => {
+        state.initializationState = InitializationState.Initializing;
+        state.initializationError = null;
+        state.initializationAttempts = 0;
+    });
+    __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Initializing providers', {
+        currentNetwork: this.state.isTestnet ? 'testnet' : 'mainnet',
+        existingProviders: Array.from(this.providers.keys()),
+        timestamp: new Date().toISOString(),
+    });
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            this.update((state) => {
+                state.initializationAttempts = attempt;
+            });
+            // Disconnect existing providers to close WebSocket connections
+            const existingProviders = Array.from(this.providers.values());
+            if (existingProviders.length > 0) {
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Disconnecting existing providers', {
+                    count: existingProviders.length,
+                    timestamp: new Date().toISOString(),
+                });
+                await Promise.all(existingProviders.map((provider) => provider.disconnect()));
+            }
+            this.providers.clear();
+            await __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_cleanupStandaloneProvider).call(this);
+            const { activeProvider } = this.state;
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Creating provider with HIP-3 configuration', {
+                hip3Enabled: __classPrivateFieldGet(this, _PerpsController_hip3Enabled, "f"),
+                hip3AllowlistMarkets: __classPrivateFieldGet(this, _PerpsController_hip3AllowlistMarkets, "f"),
+                hip3BlocklistMarkets: __classPrivateFieldGet(this, _PerpsController_hip3BlocklistMarkets, "f"),
+                hip3ConfigSource: __classPrivateFieldGet(this, _PerpsController_hip3ConfigSource, "f"),
+                isTestnet: this.state.isTestnet,
+                activeProvider,
+            });
+            // Always create HyperLiquid provider as the base provider
+            const hyperLiquidProvider = new HyperLiquidProvider({
+                isTestnet: this.state.isTestnet,
+                hip3Enabled: __classPrivateFieldGet(this, _PerpsController_hip3Enabled, "f"),
+                allowlistMarkets: __classPrivateFieldGet(this, _PerpsController_hip3AllowlistMarkets, "f"),
+                blocklistMarkets: __classPrivateFieldGet(this, _PerpsController_hip3BlocklistMarkets, "f"),
+                platformDependencies: __classPrivateFieldGet(this, _PerpsController_options, "f").infrastructure,
+                messenger: this.messenger,
+            });
+            this.providers.set('hyperliquid', hyperLiquidProvider);
+            // Register MYX provider if enabled via feature flag
+            const isMYXEnabled = __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_isMYXProviderEnabled).call(this);
+            if (isMYXEnabled) {
+                const myxProvider = new MYXProvider({
+                    isTestnet: PROVIDER_CONFIG.MYX_TESTNET_ONLY || this.state.isTestnet,
+                    platformDependencies: __classPrivateFieldGet(this, _PerpsController_options, "f").infrastructure,
+                });
+                this.providers.set('myx', myxProvider);
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: MYX provider registered', {
+                    isTestnet: PROVIDER_CONFIG.MYX_TESTNET_ONLY || this.state.isTestnet,
+                });
+            }
+            // Set up active provider based on activeProvider value in state
+            // 'aggregated' is treated as just another provider that wraps others
+            if (activeProvider === 'aggregated') {
+                // Aggregated mode: wrap in AggregatedPerpsProvider for multi-provider support
+                this.activeProviderInstance = new AggregatedPerpsProvider({
+                    providers: this.providers,
+                    defaultProvider: 'hyperliquid',
+                    infrastructure: __classPrivateFieldGet(this, _PerpsController_options, "f").infrastructure,
+                });
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Using aggregated provider (multi-provider)', { registeredProviders: Array.from(this.providers.keys()) });
+            }
+            else if (activeProvider === 'hyperliquid') {
+                // Direct provider mode: use HyperLiquid provider directly
+                this.activeProviderInstance = hyperLiquidProvider;
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, `PerpsController: Using direct provider (${activeProvider})`);
+            }
+            else if (activeProvider === 'myx') {
+                // MYX provider mode
+                const myxProvider = this.providers.get('myx');
+                if (myxProvider) {
+                    this.activeProviderInstance = myxProvider;
+                }
+                else {
+                    // MYX feature flag is disabled — fall back to HyperLiquid
+                    __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: MYX provider not available (feature flag disabled), falling back to hyperliquid');
+                    this.activeProviderInstance = hyperLiquidProvider;
+                    this.update((state) => {
+                        state.activeProvider = 'hyperliquid';
+                    });
+                }
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, `PerpsController: Using direct provider (${this.activeProviderInstance === hyperLiquidProvider ? 'hyperliquid' : activeProvider})`);
+            }
+            else {
+                // Unsupported provider - throw error to prevent silent misconfiguration
+                throw new Error(`Unsupported provider: ${String(activeProvider)}. Currently only 'hyperliquid', 'myx', and 'aggregated' are supported.`);
+            }
+            // Future providers can be added here with their own authentication patterns:
+            // - Some might use API keys: new BinanceProvider({ apiKey, apiSecret })
+            // - Some might use different wallet patterns: new GMXProvider({ signer })
+            // - Some might not need auth at all: new DydxProvider()
+            // Wait for WebSocket transport to be ready before marking as initialized
+            await wait(PERPS_CONSTANTS.ReconnectionCleanupDelayMs);
+            this.isInitialized = true;
+            this.update((state) => {
+                state.initializationState = InitializationState.Initialized;
+                state.initializationError = null;
+            });
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Providers initialized successfully', {
+                providerCount: this.providers.size,
+                activeProvider,
+                timestamp: new Date().toISOString(),
+                attempts: attempt,
+            });
+            return; // Exit retry loop on success
+        }
+        catch (error) {
+            lastError = ensureError(error, 'PerpsController.performInitialization');
+            __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, lastError, __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'performInitialization', {
+                attempt,
+                maxAttempts,
+            }));
+            // If not the last attempt, wait before retrying (exponential backoff)
+            if (attempt < maxAttempts) {
+                const delay = baseDelay * Math.pow(2, attempt - 1); // 1s, 2s, 4s
+                __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, `PerpsController: Retrying initialization in ${delay}ms`, {
+                    attempt,
+                    maxAttempts,
+                    error: lastError.message,
+                });
+                await wait(delay);
+            }
+        }
+    }
+    this.isInitialized = false;
+    this.update((state) => {
+        state.initializationState = InitializationState.Failed;
+        state.initializationError = lastError?.message ?? 'Unknown error';
+    });
+    __classPrivateFieldSet(this, _PerpsController_initializationPromise, null, "f"); // Clear promise to allow retry
+    __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Initialization failed', {
+        error: lastError?.message,
+        attempts: maxAttempts,
+        timestamp: new Date().toISOString(),
+    });
+}, _PerpsController_getErrorContext = function _PerpsController_getErrorContext(method, extra) {
+    return {
+        tags: {
+            feature: PERPS_CONSTANTS.FeatureName,
+            provider: this.state.activeProvider,
+            network: this.state.isTestnet ? 'testnet' : 'mainnet',
+        },
+        context: {
+            name: 'PerpsController',
+            data: {
+                method,
+                ...extra,
             },
+        },
+    };
+}, _PerpsController_getControllerState = function _PerpsController_getControllerState() {
+    return this.state;
+}, _PerpsController_createServiceContext = function _PerpsController_createServiceContext(method, additionalContext) {
+    return {
+        tracingContext: {
+            provider: this.state.activeProvider,
+            isTestnet: this.state.isTestnet,
+        },
+        errorContext: {
+            controller: 'PerpsController',
+            method,
+        },
+        stateManager: {
+            update: (updater) => 
+            // @ts-expect-error TS2589 - excessively deep instantiation when inferring stateManager from BaseController
+            this.update(updater),
+            getState: () => __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getControllerState).call(this),
+        },
+        ...additionalContext,
+    };
+}, _PerpsController_ensureTradingServiceDeps = function _PerpsController_ensureTradingServiceDeps() {
+    __classPrivateFieldGet(this, _PerpsController_tradingService, "f").setControllerDependencies({
+        rewardsIntegrationService: __classPrivateFieldGet(this, _PerpsController_rewardsIntegrationService, "f"),
+    });
+}, _PerpsController_performMarketDataPreload = 
+/**
+ * Perform a single market data preload (best-effort, no throw).
+ */
+async function _PerpsController_performMarketDataPreload() {
+    if (__classPrivateFieldGet(this, _PerpsController_isPreloading, "f")) {
+        return;
+    }
+    const now = Date.now();
+    if (now - this.state.cachedMarketDataTimestamp <
+        __classPrivateFieldGet(_a, _a, "f", _PerpsController_preloadGuardMs)) {
+        return;
+    }
+    __classPrivateFieldSet(this, _PerpsController_isPreloading, true, "f");
+    const traceId = uuidv4();
+    const preloadStart = performance.now();
+    let traceData;
+    try {
+        __classPrivateFieldGet(this, _PerpsController_options, "f").infrastructure.tracer.trace({
+            name: PerpsTraceNames.MarketDataPreload,
+            id: traceId,
+            op: PerpsTraceOperations.Operation,
+            tags: {
+                provider: this.state.activeProvider,
+                isTestnet: this.state.isTestnet,
+            },
+        });
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Fetching market data in background');
+        const data = await this.getMarketDataWithPrices({ standalone: true });
+        this.update((state) => {
+            state.cachedMarketData = data;
+            state.cachedMarketDataTimestamp = Date.now();
+        });
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Market data preloaded', {
+            marketCount: data.length,
+        });
+        traceData = { success: true, marketCount: data.length };
+        __classPrivateFieldGet(this, _PerpsController_options, "f").infrastructure.tracer.setMeasurement(PerpsMeasurementName.PerpsMarketDataPreload, performance.now() - preloadStart, 'millisecond');
+        // Also preload user data (fire-and-forget, non-blocking)
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_performUserDataPreload).call(this).catch(() => {
+            /* fire-and-forget */
         });
     }
-}
+    catch (error) {
+        traceData = {
+            success: false,
+            error: ensureError(error, 'PerpsController.performMarketDataPreload')
+                .message,
+        };
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.performMarketDataPreload'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'performMarketDataPreload', {
+            message: 'Background preload failed',
+        }));
+    }
+    finally {
+        __classPrivateFieldGet(this, _PerpsController_options, "f").infrastructure.tracer.endTrace({
+            name: PerpsTraceNames.MarketDataPreload,
+            id: traceId,
+            data: traceData,
+        });
+        __classPrivateFieldSet(this, _PerpsController_isPreloading, false, "f");
+    }
+}, _PerpsController_performUserDataPreload = 
+/**
+ * Perform a single user data preload (best-effort, no throw).
+ * Fetches positions, open orders, and account state via lightweight REST calls.
+ */
+async function _PerpsController_performUserDataPreload() {
+    if (__classPrivateFieldGet(this, _PerpsController_isPreloadingUserData, "f")) {
+        return;
+    }
+    // Get current user address
+    const evmAccount = getSelectedEvmAccount(this.messenger.call('AccountTreeController:getAccountsFromSelectedAccountGroup'));
+    if (!evmAccount?.address) {
+        return;
+    }
+    const userAddress = evmAccount.address;
+    // Skip if cache is fresh and for same account
+    const now = Date.now();
+    if (this.state.cachedUserDataAddress === userAddress &&
+        now - this.state.cachedUserDataTimestamp < __classPrivateFieldGet(_a, _a, "f", _PerpsController_preloadGuardMs)) {
+        return;
+    }
+    // Skip standalone REST polling when WebSocket is connected — live data is streaming
+    if (this.getWebSocketConnectionState() === WebSocketConnectionState.Connected) {
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Skipping user data preload — WebSocket connected');
+        return;
+    }
+    __classPrivateFieldSet(this, _PerpsController_isPreloadingUserData, true, "f");
+    const traceId = uuidv4();
+    const preloadStart = performance.now();
+    let traceData;
+    try {
+        __classPrivateFieldGet(this, _PerpsController_options, "f").infrastructure.tracer.trace({
+            name: PerpsTraceNames.UserDataPreload,
+            id: traceId,
+            op: PerpsTraceOperations.Operation,
+            tags: {
+                provider: this.state.activeProvider,
+                isTestnet: this.state.isTestnet,
+            },
+            data: { userAddress },
+        });
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: Fetching user data in background', {
+            userAddress,
+        });
+        const [positions, orders, accountState] = await Promise.all([
+            this.getPositions({ standalone: true, userAddress }),
+            this.getOpenOrders({ standalone: true, userAddress }),
+            this.getAccountState({ standalone: true, userAddress }),
+        ]);
+        this.update((state) => {
+            state.cachedPositions = positions;
+            state.cachedOrders = orders;
+            state.cachedAccountState = accountState;
+            state.cachedUserDataTimestamp = Date.now();
+            state.cachedUserDataAddress = userAddress;
+        });
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_debugLog).call(this, 'PerpsController: User data preloaded', {
+            positionCount: positions.length,
+            orderCount: orders.length,
+            totalBalance: accountState.totalBalance,
+        });
+        traceData = {
+            success: true,
+            positionCount: positions.length,
+            orderCount: orders.length,
+        };
+        __classPrivateFieldGet(this, _PerpsController_options, "f").infrastructure.tracer.setMeasurement(PerpsMeasurementName.PerpsUserDataPreload, performance.now() - preloadStart, 'millisecond');
+    }
+    catch (error) {
+        traceData = {
+            success: false,
+            error: ensureError(error, 'PerpsController.performUserDataPreload')
+                .message,
+        };
+        __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_logError).call(this, ensureError(error, 'PerpsController.performUserDataPreload'), __classPrivateFieldGet(this, _PerpsController_instances, "m", _PerpsController_getErrorContext).call(this, 'performUserDataPreload', {
+            message: 'Background user data preload failed',
+        }));
+    }
+    finally {
+        __classPrivateFieldGet(this, _PerpsController_options, "f").infrastructure.tracer.endTrace({
+            name: PerpsTraceNames.UserDataPreload,
+            id: traceId,
+            data: traceData,
+        });
+        __classPrivateFieldSet(this, _PerpsController_isPreloadingUserData, false, "f");
+    }
+};
+// ============================================================================
+// Market Data Preload (client-agnostic background caching)
+// ============================================================================
+/** State paths that the preload stateChange handler reads. */
+_PerpsController_preloadWatchedPaths = { value: new Set([
+        'isTestnet',
+        'hip3ConfigVersion',
+    ]) };
+_PerpsController_preloadRefreshMs = { value: 5 * 60 * 1000 }; // 5 min
+_PerpsController_preloadGuardMs = { value: 30000 }; // 30s debounce
 //# sourceMappingURL=PerpsController.mjs.map