@metamask-previews/perps-controller 0.0.0-preview-ae46ab603 → 0.0.0-preview-e4aa1532

package/dist/PerpsController.cjs

@@ -1,87 +1,2245 @@
 "use strict";
+// Note: ESLint rules below are disabled because this file was migrated from Mobile
+// which has different ESLint configurations. The following rules are Core-specific
+// and would require extensive refactoring to satisfy. The code is functionally correct.
+/* eslint-disable jsdoc/require-param-description, jsdoc/require-returns */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable @typescript-eslint/naming-convention */
+/* eslint-disable id-denylist, id-length */
+/* eslint-disable consistent-return */
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable promise/always-return */
+/* eslint-disable @typescript-eslint/prefer-nullish-coalescing */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PerpsController = exports.getDefaultPerpsControllerState = exports.controllerName = void 0;
+exports.PerpsController = exports.getDefaultPerpsControllerState = exports.InitializationState = exports.PERPS_ERROR_CODES = void 0;
 const base_controller_1 = require("@metamask/base-controller");
+const transaction_controller_1 = require("@metamask/transaction-controller");
+const eventNames_1 = require("./constants/eventNames.cjs");
+const hyperLiquidConfig_1 = require("./constants/hyperLiquidConfig.cjs");
+const perpsConfig_1 = require("./constants/perpsConfig.cjs");
+const perpsErrorCodes_1 = require("./constants/perpsErrorCodes.cjs");
+const AggregatedPerpsProvider_1 = require("./providers/AggregatedPerpsProvider.cjs");
+const HyperLiquidProvider_1 = require("./providers/HyperLiquidProvider.cjs");
+const AccountService_1 = require("./services/AccountService.cjs");
+const DataLakeService_1 = require("./services/DataLakeService.cjs");
+const DepositService_1 = require("./services/DepositService.cjs");
+const EligibilityService_1 = require("./services/EligibilityService.cjs");
+const FeatureFlagConfigurationService_1 = require("./services/FeatureFlagConfigurationService.cjs");
+const MarketDataService_1 = require("./services/MarketDataService.cjs");
+const RewardsIntegrationService_1 = require("./services/RewardsIntegrationService.cjs");
+const TradingService_1 = require("./services/TradingService.cjs");
+const types_1 = require("./types/index.cjs");
+const types_2 = require("./types/index.cjs");
+const chart_1 = require("./types/chart.cjs");
+const errorUtils_1 = require("./utils/errorUtils.cjs");
+const wait_1 = require("./utils/wait.cjs");
+// Re-export error codes from separate file to avoid circular dependencies
+var perpsErrorCodes_2 = require("./constants/perpsErrorCodes.cjs");
+Object.defineProperty(exports, "PERPS_ERROR_CODES", { enumerable: true, get: function () { return perpsErrorCodes_2.PERPS_ERROR_CODES; } });
 /**
- * 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
  */
-exports.controllerName = 'PerpsController';
+var InitializationState;
+(function (InitializationState) {
+    InitializationState["Uninitialized"] = "uninitialized";
+    InitializationState["Initializing"] = "initializing";
+    InitializationState["Initialized"] = "initialized";
+    InitializationState["Failed"] = "failed";
+})(InitializationState || (exports.InitializationState = InitializationState = {}));
 /**
- * The metadata for each property in {@link PerpsControllerState}.
- */
-const perpsControllerMetadata = {};
-/**
- * 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.
+ * Get default PerpsController state
  *
- * @returns The default {@link 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)
  */
-function getDefaultPerpsControllerState() {
-    return {};
-}
+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: perpsConfig_1.MARKET_SORTING_CONFIG.DefaultSortOptionId,
+        direction: perpsConfig_1.MARKET_SORTING_CONFIG.DefaultDirection,
+    },
+    hip3ConfigVersion: 0,
+});
 exports.getDefaultPerpsControllerState = getDefaultPerpsControllerState;
 /**
- * `PerpsController` manages perpetual trading functionality in MetaMask.
- *
- * This controller provides platform-agnostic perps trading capabilities.
- *
- * @example
- *
- * ``` ts
- * import { Messenger } from '@metamask/messenger';
- * import type {
- *   PerpsControllerActions,
- *   PerpsControllerEvents,
- * } from '@metamask/perps-controller';
- * import { PerpsController } from '@metamask/perps-controller';
- *
- * 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,
- * });
+ * State metadata for the PerpsController
+ */
+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,
+    },
+};
+/**
+ * PerpsController - Protocol-agnostic perpetuals trading controller
  *
- * const perpsControllerState = await rootMessenger.call(
- *   'PerpsController:getState',
- * );
- * ```
+ * 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
  */
 class PerpsController extends base_controller_1.BaseController {
+    constructor({ messenger, state = {}, clientConfig = {}, infrastructure, }) {
+        super({
+            name: 'PerpsController',
+            metadata,
+            messenger,
+            state: { ...(0, exports.getDefaultPerpsControllerState)(), ...state },
+        });
+        this.isInitialized = false;
+        this.initializationPromise = null;
+        this.isReinitializing = 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).
+         */
+        this.blockedRegionListVersion = 0;
+        this.hip3ConfigSource = '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;
+        // Store options for dependency injection
+        this.options = {
+            messenger,
+            state,
+            clientConfig,
+            infrastructure,
+        };
+        // Instantiate services with platform dependencies
+        this.tradingService = new TradingService_1.TradingService(infrastructure);
+        this.marketDataService = new MarketDataService_1.MarketDataService(infrastructure);
+        this.accountService = new AccountService_1.AccountService(infrastructure);
+        this.eligibilityService = new EligibilityService_1.EligibilityService(infrastructure);
+        this.dataLakeService = new DataLakeService_1.DataLakeService(infrastructure);
+        this.depositService = new DepositService_1.DepositService(infrastructure);
+        this.featureFlagConfigurationService = new FeatureFlagConfigurationService_1.FeatureFlagConfigurationService(infrastructure);
+        this.rewardsIntegrationService = new RewardsIntegrationService_1.RewardsIntegrationService(infrastructure);
+        // Set HIP-3 fallback configuration from client (will be updated if remote flags available)
+        this.hip3Enabled = clientConfig.fallbackHip3Enabled ?? false;
+        this.hip3AllowlistMarkets = [
+            ...(clientConfig.fallbackHip3AllowlistMarkets ?? []),
+        ];
+        this.hip3BlocklistMarkets = [
+            ...(clientConfig.fallbackHip3BlocklistMarkets ?? []),
+        ];
+        // 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
+            this.logError((0, errorUtils_1.ensureError)(error), this.getErrorContext('constructor', {
+                operation: 'readRemoteFeatureFlags',
+            }));
+        }
+        this.messenger.subscribe('RemoteFeatureFlagController:stateChange', this.refreshEligibilityOnFeatureFlagChange.bind(this));
+        this.providers = new Map();
+        // Migrate old persisted data without accountAddress
+        this.migrateRequestsIfNeeded();
+    }
+    // ============================================================================
+    // Infrastructure Access Methods
+    // These methods provide access to platform-specific infrastructure via dependency injection.
+    // Infrastructure is required and must be provided at instantiation time.
+    // ============================================================================
     /**
-     * Constructs a new {@link PerpsController}.
+     * Log an error using injected infrastructure logger
      *
-     * @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.
+     * @param error
+     * @param options
      */
-    constructor({ messenger, state, }) {
-        super({
-            messenger,
-            metadata: perpsControllerMetadata,
-            name: exports.controllerName,
-            state: {
-                ...getDefaultPerpsControllerState(),
-                ...state,
+    logError(error, options) {
+        this.options.infrastructure.logger.error(error, options);
+    }
+    /**
+     * Log debug message using injected infrastructure debugLogger
+     *
+     * @param args
+     */
+    debugLog(...args) {
+        this.options.infrastructure.debugLogger.log(...args);
+    }
+    /**
+     * Debug method for validating Core integration.
+     * Logs via injected debugLogger and returns debug info.
+     *
+     * @returns Debug information object
+     */
+    debug() {
+        const debugInfo = {
+            timestamp: new Date().toISOString(),
+            source: '@metamask/perps-controller',
+            message: 'DEBUG v5 - Hello from Core PerpsController!',
+        };
+        this.debugLog('[PerpsController.debug]', debugInfo);
+        return debugInfo;
+    }
+    /**
+     * Get metrics instance from platform dependencies
+     */
+    getMetrics() {
+        return this.options.infrastructure.metrics;
+    }
+    /**
+     * Clean up old withdrawal/deposit requests that don't have accountAddress
+     * These are from before the accountAddress field was added and can't be displayed
+     * in the UI (which filters by account), so we discard them
+     */
+    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));
+        });
+    }
+    setBlockedRegionList(list, source) {
+        this.featureFlagConfigurationService.setBlockedRegions({
+            list,
+            source,
+            context: this.createServiceContext('setBlockedRegionList', {
+                getBlockedRegionList: () => this.blockedRegionList,
+                setBlockedRegionList: (newList, newSource) => {
+                    this.blockedRegionList = { list: newList, source: newSource };
+                    this.blockedRegionListVersion += 1;
+                },
+                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
+     */
+    refreshEligibilityOnFeatureFlagChange(remoteFeatureFlagControllerState) {
+        this.featureFlagConfigurationService.refreshEligibility({
+            remoteFeatureFlagControllerState,
+            context: this.createServiceContext('refreshEligibilityOnFeatureFlagChange', {
+                getBlockedRegionList: () => this.blockedRegionList,
+                setBlockedRegionList: (list, source) => {
+                    this.blockedRegionList = { list, source };
+                    this.blockedRegionListVersion += 1;
+                },
+                refreshEligibility: () => this.refreshEligibility(),
+                getHip3Config: () => ({
+                    enabled: this.hip3Enabled,
+                    allowlistMarkets: this.hip3AllowlistMarkets,
+                    blocklistMarkets: this.hip3BlocklistMarkets,
+                    source: this.hip3ConfigSource,
+                }),
+                setHip3Config: (config) => {
+                    if (config.enabled !== undefined) {
+                        this.hip3Enabled = config.enabled;
+                    }
+                    if (config.allowlistMarkets !== undefined) {
+                        this.hip3AllowlistMarkets = [...config.allowlistMarkets];
+                    }
+                    if (config.blocklistMarkets !== undefined) {
+                        this.hip3BlocklistMarkets = [...config.blocklistMarkets];
+                    }
+                    if (config.source !== undefined) {
+                        this.hip3ConfigSource = config.source;
+                    }
+                },
+                incrementHip3ConfigVersion: () => {
+                    const newVersion = (this.state.hip3ConfigVersion || 0) + 1;
+                    this.update((state) => {
+                        state.hip3ConfigVersion = newVersion;
+                    });
+                    return newVersion;
+                },
+            }),
+        });
+    }
+    /**
+     * Execute an operation while temporarily pausing specified stream channels
+     * to prevent WebSocket updates from triggering UI re-renders during operations.
+     *
+     * WebSocket connections remain alive but updates are not emitted to subscribers.
+     * This prevents race conditions where UI re-renders fetch stale data during operations.
+     *
+     * @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']
+     * );
+     *
+     * // Close positions and pause multiple streams
+     * await this.withStreamPause(
+     *   async () => this.provider.closePositions(positions),
+     *   ['positions', 'account', 'orders']
+     * );
+     * ```
+     */
+    async withStreamPause(operation, channels) {
+        const pausedChannels = [];
+        const { streamManager } = this.options.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 (err) {
+                // Log error to Sentry but continue pausing remaining channels
+                this.logError((0, errorUtils_1.ensureError)(err), this.getErrorContext('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 (err) {
+                    // Log error to Sentry but continue resuming remaining channels
+                    this.logError((0, errorUtils_1.ensureError)(err), this.getErrorContext('withStreamPause', {
+                        operation: 'resume',
+                        channel: String(channel),
+                        pausedChannels: pausedChannels.join(','),
+                    }));
+                }
+            }
+        }
+    }
+    /**
+     * Initialize the PerpsController providers
+     * Must be called before using any other methods
+     * Prevents double initialization with promise caching
+     */
+    async init() {
+        if (this.isInitialized) {
+            return;
+        }
+        if (this.initializationPromise) {
+            return this.initializationPromise;
+        }
+        this.initializationPromise = this.performInitialization();
+        return this.initializationPromise;
+    }
+    /**
+     * Actual initialization implementation with retry logic
+     */
+    async performInitialization() {
+        const maxAttempts = 3;
+        const baseDelay = 1000;
+        this.update((state) => {
+            state.initializationState = InitializationState.Initializing;
+            state.initializationError = null;
+            state.initializationAttempts = 0;
+        });
+        this.debugLog('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) {
+                    this.debugLog('PerpsController: Disconnecting existing providers', {
+                        count: existingProviders.length,
+                        timestamp: new Date().toISOString(),
+                    });
+                    await Promise.all(existingProviders.map((provider) => provider.disconnect()));
+                }
+                this.providers.clear();
+                const { activeProvider } = this.state;
+                this.debugLog('PerpsController: Creating provider with HIP-3 configuration', {
+                    hip3Enabled: this.hip3Enabled,
+                    hip3AllowlistMarkets: this.hip3AllowlistMarkets,
+                    hip3BlocklistMarkets: this.hip3BlocklistMarkets,
+                    hip3ConfigSource: this.hip3ConfigSource,
+                    isTestnet: this.state.isTestnet,
+                    activeProvider,
+                });
+                // Always create HyperLiquid provider as the base provider
+                const hyperLiquidProvider = new HyperLiquidProvider_1.HyperLiquidProvider({
+                    isTestnet: this.state.isTestnet,
+                    hip3Enabled: this.hip3Enabled,
+                    allowlistMarkets: this.hip3AllowlistMarkets,
+                    blocklistMarkets: this.hip3BlocklistMarkets,
+                    platformDependencies: this.options.infrastructure,
+                });
+                this.providers.set('hyperliquid', hyperLiquidProvider);
+                // 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
+                    // Future: register additional providers here (MYX, etc.)
+                    this.activeProviderInstance = new AggregatedPerpsProvider_1.AggregatedPerpsProvider({
+                        providers: this.providers,
+                        defaultProvider: 'hyperliquid',
+                        infrastructure: this.options.infrastructure,
+                    });
+                    this.debugLog('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;
+                    this.debugLog(`PerpsController: Using direct provider (${activeProvider})`);
+                }
+                else {
+                    // Unsupported provider - throw error to prevent silent misconfiguration
+                    throw new Error(`Unsupported provider: ${activeProvider}. Currently only 'hyperliquid' 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 (0, wait_1.wait)(perpsConfig_1.PERPS_CONSTANTS.ReconnectionCleanupDelayMs);
+                this.isInitialized = true;
+                this.update((state) => {
+                    state.initializationState = InitializationState.Initialized;
+                    state.initializationError = null;
+                });
+                this.debugLog('PerpsController: Providers initialized successfully', {
+                    providerCount: this.providers.size,
+                    activeProvider,
+                    timestamp: new Date().toISOString(),
+                    attempts: attempt,
+                });
+                return; // Exit retry loop on success
+            }
+            catch (error) {
+                lastError = (0, errorUtils_1.ensureError)(error);
+                this.logError(lastError, this.getErrorContext('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
+                    this.debugLog(`PerpsController: Retrying initialization in ${delay}ms`, {
+                        attempt,
+                        maxAttempts,
+                        error: lastError.message,
+                    });
+                    await (0, wait_1.wait)(delay);
+                }
+            }
+        }
+        this.isInitialized = false;
+        this.update((state) => {
+            state.initializationState = InitializationState.Failed;
+            state.initializationError = lastError?.message ?? 'Unknown error';
+        });
+        this.initializationPromise = null; // Clear promise to allow retry
+        this.debugLog('PerpsController: Initialization failed', {
+            error: lastError?.message,
+            attempts: maxAttempts,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    /**
+     * Generate standard error context for Logger.error calls with searchable tags and context.
+     * Enables Sentry dashboard filtering by feature, provider, and network.
+     *
+     * @param method - The method name where the error occurred
+     * @param extra - Optional additional context fields (becomes searchable context data)
+     * @returns PerpsLoggerOptions with tags (searchable) and context (searchable)
+     * @private
+     *
+     * @example
+     * this.logError(error, this.getErrorContext('placeOrder', { symbol: 'BTC', operation: 'validate' }));
+     * // Creates searchable tags: feature:perps, provider:hyperliquid, network:mainnet
+     * // Creates searchable context: perps_controller.method:placeOrder, perps_controller.symbol:BTC, perps_controller.operation:validate
+     */
+    getErrorContext(method, extra) {
+        return {
+            tags: {
+                feature: perpsConfig_1.PERPS_CONSTANTS.FeatureName,
+                provider: this.state.activeProvider,
+                network: this.state.isTestnet ? 'testnet' : 'mainnet',
+            },
+            context: {
+                name: 'PerpsController',
+                data: {
+                    method,
+                    ...extra,
+                },
+            },
+        };
+    }
+    /**
+     * Create a ServiceContext for dependency injection into services
+     * Provides all orchestration dependencies (tracing, analytics, state management)
+     *
+     * @param method - Method name for error context
+     * @param additionalContext - Optional additional context (e.g., rewardsController, streamManager)
+     * @returns ServiceContext with all required dependencies
+     */
+    createServiceContext(method, additionalContext) {
+        return {
+            tracingContext: {
+                provider: this.state.activeProvider,
+                isTestnet: this.state.isTestnet,
+            },
+            errorContext: {
+                controller: 'PerpsController',
+                method,
+            },
+            stateManager: {
+                update: (updater) => this.update(updater),
+                getState: () => this.state,
             },
+            ...additionalContext,
+        };
+    }
+    /**
+     * Ensure TradingService has controller dependencies set.
+     * Uses injectable dependencies from infrastructure for core migration compatibility.
+     */
+    ensureTradingServiceDeps() {
+        const { controllers } = this.options.infrastructure;
+        this.tradingService.setControllerDependencies({
+            controllers,
+            messenger: this.messenger,
+            rewardsIntegrationService: this.rewardsIntegrationService,
+        });
+    }
+    /**
+     * 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.isReinitializing) {
+            this.update((state) => {
+                state.lastError = perpsErrorCodes_1.PERPS_ERROR_CODES.CLIENT_REINITIALIZING;
+                state.lastUpdateTimestamp = Date.now();
+            });
+            throw new Error(perpsErrorCodes_1.PERPS_ERROR_CODES.CLIENT_REINITIALIZING);
+        }
+        // Check if not initialized
+        if (this.state.initializationState !== InitializationState.Initialized ||
+            !this.isInitialized) {
+            const errorMessage = this.state.initializationState === InitializationState.Failed
+                ? `${perpsErrorCodes_1.PERPS_ERROR_CODES.CLIENT_NOT_INITIALIZED}: ${this.state.initializationError || 'Initialization failed'}`
+                : perpsErrorCodes_1.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 = perpsErrorCodes_1.PERPS_ERROR_CODES.PROVIDER_NOT_AVAILABLE;
+                state.lastUpdateTimestamp = Date.now();
+            });
+            throw new Error(perpsErrorCodes_1.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.isReinitializing) {
+            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
+     */
+    async placeOrder(params) {
+        const provider = this.getActiveProvider();
+        this.ensureTradingServiceDeps();
+        return this.tradingService.placeOrder({
+            provider,
+            params,
+            context: this.createServiceContext('placeOrder', {
+                saveTradeConfiguration: (symbol, leverage) => this.saveTradeConfiguration(symbol, leverage),
+            }),
+            reportOrderToDataLake: (dataLakeParams) => this.reportOrderToDataLake(dataLakeParams),
+        });
+    }
+    /**
+     * Edit an existing order
+     * Thin delegation to TradingService
+     *
+     * @param params
+     */
+    async editOrder(params) {
+        const provider = this.getActiveProvider();
+        this.ensureTradingServiceDeps();
+        return this.tradingService.editOrder({
+            provider,
+            params,
+            context: this.createServiceContext('editOrder'),
+        });
+    }
+    /**
+     * Cancel an existing order
+     *
+     * @param params
+     */
+    async cancelOrder(params) {
+        const provider = this.getActiveProvider();
+        return this.tradingService.cancelOrder({
+            provider,
+            params,
+            context: this.createServiceContext('cancelOrder'),
+        });
+    }
+    /**
+     * Cancel multiple orders in parallel
+     * Batch version of cancelOrder() that cancels multiple orders simultaneously
+     *
+     * @param params
+     */
+    async cancelOrders(params) {
+        const provider = this.getActiveProvider();
+        return this.tradingService.cancelOrders({
+            provider,
+            params,
+            context: this.createServiceContext('cancelOrders', {
+                getOpenOrders: () => this.getOpenOrders(),
+            }),
+            withStreamPause: (operation, channels) => this.withStreamPause(operation, channels),
+        });
+    }
+    /**
+     * Close a position (partial or full)
+     * Thin delegation to TradingService
+     *
+     * @param params
+     */
+    async closePosition(params) {
+        const provider = this.getActiveProvider();
+        this.ensureTradingServiceDeps();
+        return this.tradingService.closePosition({
+            provider,
+            params,
+            context: this.createServiceContext('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
+     */
+    async closePositions(params) {
+        const provider = this.getActiveProvider();
+        this.ensureTradingServiceDeps();
+        return this.tradingService.closePositions({
+            provider,
+            params,
+            context: this.createServiceContext('closePositions', {
+                getPositions: () => this.getPositions(),
+            }),
+        });
+    }
+    /**
+     * Update TP/SL for an existing position
+     *
+     * @param params
+     */
+    async updatePositionTPSL(params) {
+        const provider = this.getActiveProvider();
+        this.ensureTradingServiceDeps();
+        return this.tradingService.updatePositionTPSL({
+            provider,
+            params,
+            context: this.createServiceContext('updatePositionTPSL'),
+        });
+    }
+    /**
+     * Update margin for an existing position (add or remove)
+     *
+     * @param params
+     */
+    async updateMargin(params) {
+        const provider = this.getActiveProvider();
+        this.ensureTradingServiceDeps();
+        return this.tradingService.updateMargin({
+            provider,
+            symbol: params.symbol,
+            amount: params.amount,
+            context: this.createServiceContext('updateMargin'),
+        });
+    }
+    /**
+     * Flip position (reverse direction while keeping size and leverage)
+     *
+     * @param params
+     */
+    async flipPosition(params) {
+        const provider = this.getActiveProvider();
+        this.ensureTradingServiceDeps();
+        return this.tradingService.flipPosition({
+            provider,
+            position: params.position,
+            context: this.createServiceContext('flipPosition'),
+        });
+    }
+    /**
+     * Simplified deposit method that prepares transaction for confirmation screen
+     * No complex state tracking - just sets a loading flag
+     *
+     * @param amount
+     */
+    async depositWithConfirmation(amount) {
+        const { controllers } = this.options.infrastructure;
+        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 } = await this.depositService.prepareTransaction({ provider });
+            this.update((state) => {
+                state.lastDepositResult = null;
+                // Get current account address via infrastructure
+                const evmAccount = this.options.infrastructure.controllers.accounts.getSelectedEvmAccount();
+                const accountAddress = evmAccount?.address || 'unknown';
+                // Add deposit request to tracking
+                const depositRequest = {
+                    id: currentDepositId,
+                    timestamp: Date.now(),
+                    amount: amount || '0', // Use provided amount or default to '0'
+                    asset: hyperLiquidConfig_1.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 = controllers.network.findNetworkClientIdForChain(assetChainId);
+            if (!networkClientId) {
+                throw new Error(`No network client found for chain ${assetChainId}. Please add the network first.`);
+            }
+            const gasFeeToken = transaction.to &&
+                assetChainId.toLowerCase() === hyperLiquidConfig_1.ARBITRUM_MAINNET_CHAIN_ID_HEX &&
+                transaction.to.toLowerCase() ===
+                    hyperLiquidConfig_1.USDC_ARBITRUM_MAINNET_ADDRESS.toLowerCase()
+                ? transaction.to
+                : undefined;
+            // submit shows the confirmation screen and returns a promise
+            // The promise will resolve when transaction completes or reject if cancelled/failed
+            const { result, transactionMeta } = await controllers.transaction.submit(transaction, {
+                networkClientId,
+                origin: 'metamask',
+                type: transaction_controller_1.TransactionType.perpsDeposit,
+                skipInitialGasEstimate: true,
+                gasFeeToken,
+            });
+            // Store the transaction ID and try to get amount from transaction
+            this.update((state) => {
+                state.lastDepositTransactionId = transactionMeta.id;
+            });
+            // 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: hyperLiquidConfig_1.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);
+            })
+                .catch((error) => {
+                // Check if user denied/cancelled the transaction
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                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
+                    });
+                }
+                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: hyperLiquidConfig_1.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;
+                            }
+                        }
+                    });
+                }
+            });
+            return {
+                result,
+            };
+        }
+        catch (error) {
+            // Check if user denied/cancelled the transaction
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            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
+                });
+            }
+            throw error;
+        }
+    }
+    /**
+     * 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
+     * @param status
+     * @param txHash
+     */
+    updateWithdrawalStatus(withdrawalId, status, txHash) {
+        let withdrawalAmount;
+        this.update((state) => {
+            const withdrawalIndex = state.withdrawalRequests.findIndex((request) => request.id === withdrawalId);
+            if (withdrawalIndex >= 0) {
+                const request = state.withdrawalRequests[withdrawalIndex];
+                withdrawalAmount = request.amount;
+                const originalStatus = request.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,
+                    };
+                }
+                // Track withdrawal transaction completed/failed (confirmed via HyperLiquid API)
+                if (withdrawalAmount !== undefined && originalStatus !== status) {
+                    this.getMetrics().trackPerpsEvent(types_2.PerpsAnalyticsEvent.WithdrawalTransaction, {
+                        [eventNames_1.PerpsEventProperties.STATUS]: status === 'completed'
+                            ? eventNames_1.PerpsEventValues.STATUS.COMPLETED
+                            : eventNames_1.PerpsEventValues.STATUS.FAILED,
+                        [eventNames_1.PerpsEventProperties.WITHDRAWAL_AMOUNT]: Number.parseFloat(withdrawalAmount),
+                    });
+                }
+                this.debugLog('PerpsController: Updated withdrawal status', {
+                    withdrawalId,
+                    status,
+                    txHash,
+                });
+            }
+        });
+    }
+    /**
+     * Update withdrawal progress (persistent across navigation)
+     *
+     * @param progress
+     * @param activeWithdrawalId
+     */
+    updateWithdrawalProgress(progress, activeWithdrawalId = null) {
+        this.update((state) => {
+            state.withdrawalProgress = {
+                progress,
+                lastUpdated: Date.now(),
+                activeWithdrawalId,
+            };
+        });
+    }
+    /**
+     * Get current withdrawal progress
+     */
+    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 this.accountService.withdraw({
+            provider,
+            params,
+            context: this.createServiceContext('withdraw'),
+            refreshAccountState: async () => {
+                await this.getAccountState({ source: 'post_withdrawal' });
+            },
+        });
+    }
+    /**
+     * Get current positions
+     * Thin delegation to MarketDataService
+     *
+     * @param params
+     */
+    async getPositions(params) {
+        const provider = this.getActiveProvider();
+        return this.marketDataService.getPositions({
+            provider,
+            params,
+            context: this.createServiceContext('getPositions'),
+        });
+    }
+    /**
+     * Get historical user fills (trade executions)
+     * Thin delegation to MarketDataService
+     *
+     * @param params
+     */
+    async getOrderFills(params) {
+        const provider = this.getActiveProvider();
+        return this.marketDataService.getOrderFills({
+            provider,
+            params,
+            context: this.createServiceContext('getOrderFills'),
+        });
+    }
+    /**
+     * Get historical user orders (order lifecycle)
+     * Thin delegation to MarketDataService
+     *
+     * @param params
+     */
+    async getOrders(params) {
+        const provider = this.getActiveProvider();
+        return this.marketDataService.getOrders({
+            provider,
+            params,
+            context: this.createServiceContext('getOrders'),
+        });
+    }
+    /**
+     * Get currently open orders (real-time status)
+     * Thin delegation to MarketDataService
+     *
+     * @param params
+     */
+    async getOpenOrders(params) {
+        const provider = this.getActiveProvider();
+        return this.marketDataService.getOpenOrders({
+            provider,
+            params,
+            context: this.createServiceContext('getOpenOrders'),
+        });
+    }
+    /**
+     * Get historical user funding history (funding payments)
+     * Thin delegation to MarketDataService
+     *
+     * @param params
+     */
+    async getFunding(params) {
+        const provider = this.getActiveProvider();
+        return this.marketDataService.getFunding({
+            provider,
+            params,
+            context: this.createServiceContext('getFunding'),
+        });
+    }
+    /**
+     * Get account state (balances, etc.)
+     * Thin delegation to MarketDataService
+     *
+     * @param params
+     */
+    async getAccountState(params) {
+        const provider = this.getActiveProvider();
+        return this.marketDataService.getAccountState({
+            provider,
+            params,
+            context: this.createServiceContext('getAccountState'),
+        });
+    }
+    /**
+     * Get historical portfolio data
+     * Thin delegation to MarketDataService
+     *
+     * @param params
+     */
+    async getHistoricalPortfolio(params) {
+        const provider = this.getActiveProvider();
+        return this.marketDataService.getHistoricalPortfolio({
+            provider,
+            params,
+            context: this.createServiceContext('getHistoricalPortfolio'),
+        });
+    }
+    /**
+     * Get available markets with optional filtering
+     * Thin delegation to MarketDataService
+     *
+     * For readOnly mode, bypasses getActiveProvider() to allow market discovery
+     * without full perps initialization (e.g., for discovery banners on spot screens)
+     *
+     * @param params
+     */
+    async getMarkets(params) {
+        // For readOnly mode, access provider directly without initialization check
+        // This allows discovery use cases (checking if market exists) without full perps setup
+        if (params?.readOnly) {
+            // Try to get existing provider, or create a temporary one for readOnly queries
+            // Note: 'aggregated' mode uses activeProviderInstance directly, not the providers map
+            const { activeProvider } = this.state;
+            let provider = activeProvider === 'aggregated'
+                ? undefined
+                : this.providers.get(activeProvider);
+            // Create a temporary provider instance for readOnly queries
+            // The readOnly path in provider creates a standalone InfoClient without full init
+            provider ?? (provider = new HyperLiquidProvider_1.HyperLiquidProvider({
+                isTestnet: this.state.isTestnet,
+                hip3Enabled: this.hip3Enabled,
+                allowlistMarkets: this.hip3AllowlistMarkets,
+                blocklistMarkets: this.hip3BlocklistMarkets,
+                platformDependencies: this.options.infrastructure,
+            }));
+            return provider.getMarkets(params);
+        }
+        const provider = this.getActiveProvider();
+        return this.marketDataService.getMarkets({
+            provider,
+            params,
+            context: this.createServiceContext('getMarkets'),
+        });
+    }
+    /**
+     * 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 = this.createServiceContext('getAvailableDexs');
+        return this.marketDataService.getAvailableDexs({
+            provider,
+            params,
+            context,
+        });
+    }
+    /**
+     * Fetch historical candle data
+     * Thin delegation to MarketDataService
+     *
+     * @param symbol
+     * @param interval
+     * @param limit
+     * @param endTime
+     */
+    async fetchHistoricalCandles(symbol, interval, limit = 100, endTime) {
+        const provider = this.getActiveProvider();
+        return this.marketDataService.fetchHistoricalCandles({
+            provider,
+            symbol,
+            interval,
+            limit,
+            endTime,
+            context: this.createServiceContext('fetchHistoricalCandles'),
+        });
+    }
+    /**
+     * Calculate liquidation price for a position
+     * Uses provider-specific formulas based on protocol rules
+     *
+     * @param params
+     */
+    async calculateLiquidationPrice(params) {
+        const provider = this.getActiveProvider();
+        const context = this.createServiceContext('calculateLiquidationPrice');
+        return this.marketDataService.calculateLiquidationPrice({
+            provider,
+            params,
+            context,
+        });
+    }
+    /**
+     * Calculate maintenance margin for a specific asset
+     * Returns a percentage (e.g., 0.0125 for 1.25%)
+     *
+     * @param params
+     */
+    async calculateMaintenanceMargin(params) {
+        const provider = this.getActiveProvider();
+        const context = this.createServiceContext('calculateMaintenanceMargin');
+        return this.marketDataService.calculateMaintenanceMargin({
+            provider,
+            params,
+            context,
+        });
+    }
+    /**
+     * Get maximum leverage allowed for an asset
+     *
+     * @param asset
+     */
+    async getMaxLeverage(asset) {
+        const provider = this.getActiveProvider();
+        const context = this.createServiceContext('getMaxLeverage');
+        return this.marketDataService.getMaxLeverage({ provider, asset, context });
+    }
+    /**
+     * Validate order parameters according to protocol-specific rules
+     *
+     * @param params
+     */
+    async validateOrder(params) {
+        const provider = this.getActiveProvider();
+        const context = this.createServiceContext('validateOrder');
+        return this.marketDataService.validateOrder({ provider, params, context });
+    }
+    /**
+     * Validate close position parameters according to protocol-specific rules
+     *
+     * @param params
+     */
+    async validateClosePosition(params) {
+        const provider = this.getActiveProvider();
+        const context = this.createServiceContext('validateClosePosition');
+        return this.marketDataService.validateClosePosition({
+            provider,
+            params,
+            context,
+        });
+    }
+    /**
+     * Validate withdrawal parameters according to protocol-specific rules
+     *
+     * @param params
+     */
+    async validateWithdrawal(params) {
+        const provider = this.getActiveProvider();
+        return this.accountService.validateWithdrawal({ provider, params });
+    }
+    /**
+     * Get supported withdrawal routes - returns complete asset and routing information
+     */
+    getWithdrawalRoutes() {
+        try {
+            const provider = this.getActiveProvider();
+            return this.marketDataService.getWithdrawalRoutes({ provider });
+        }
+        catch (error) {
+            this.logError((0, errorUtils_1.ensureError)(error), this.getErrorContext('getWithdrawalRoutes'));
+            // Return empty array if provider is not available
+            return [];
+        }
+    }
+    /**
+     * Toggle between testnet and mainnet
+     */
+    async toggleTestnet() {
+        // Prevent concurrent reinitializations
+        if (this.isReinitializing) {
+            this.debugLog('PerpsController: Already reinitializing, skipping toggle', {
+                timestamp: new Date().toISOString(),
+            });
+            return {
+                success: false,
+                isTestnet: this.state.isTestnet,
+                error: perpsErrorCodes_1.PERPS_ERROR_CODES.CLIENT_REINITIALIZING,
+            };
+        }
+        this.isReinitializing = true;
+        try {
+            const previousNetwork = this.state.isTestnet ? 'testnet' : 'mainnet';
+            this.update((state) => {
+                state.isTestnet = !state.isTestnet;
+            });
+            const newNetwork = this.state.isTestnet ? 'testnet' : 'mainnet';
+            this.debugLog('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;
+            this.initializationPromise = null;
+            await this.init();
+            this.debugLog('PerpsController: Network toggle completed', {
+                newNetwork,
+                isTestnet: this.state.isTestnet,
+                timestamp: new Date().toISOString(),
+            });
+            return { success: true, isTestnet: this.state.isTestnet };
+        }
+        catch (error) {
+            return {
+                success: false,
+                isTestnet: this.state.isTestnet,
+                error: error instanceof Error
+                    ? error.message
+                    : perpsErrorCodes_1.PERPS_ERROR_CODES.UNKNOWN_ERROR,
+            };
+        }
+        finally {
+            this.isReinitializing = false;
+        }
+    }
+    /**
+     * Switch to a different provider
+     *
+     * @param providerId
+     */
+    async switchProvider(providerId) {
+        // '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`,
+            };
+        }
+        this.update((state) => {
+            state.activeProvider = providerId;
+        });
+        return { success: true, providerId };
+    }
+    /**
+     * Get current network (mainnet/testnet)
+     */
+    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 types_1.WebSocketConnectionState.Disconnected;
+        }
+        catch {
+            // If no provider is active, return disconnected
+            return types_1.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(types_1.WebSocketConnectionState.Disconnected, 0);
+            return () => {
+                // No-op
+            };
+        }
+    }
+    /**
+     * Manually trigger a WebSocket reconnection attempt.
+     * Used by the UI retry button when connection is lost.
+     */
+    async reconnect() {
+        this.debugLog('[PerpsController] reconnect() called');
+        try {
+            const provider = this.getActiveProvider();
+            if (provider.reconnect) {
+                this.debugLog('[PerpsController] Delegating to provider.reconnect()');
+                await provider.reconnect();
+                this.debugLog('[PerpsController] provider.reconnect() completed');
+            }
+            else {
+                this.debugLog('[PerpsController] Provider does not support reconnect()');
+            }
+        }
+        catch (error) {
+            this.logError((0, errorUtils_1.ensureError)(error), this.getErrorContext('reconnect', {
+                operation: 'websocket_reconnect',
+            }));
+        }
+    }
+    // Live data delegation (NO Redux) - delegates to active provider
+    /**
+     * Subscribe to live price updates
+     *
+     * @param params
+     */
+    subscribeToPrices(params) {
+        try {
+            const provider = this.getActiveProvider();
+            return provider.subscribeToPrices(params);
+        }
+        catch (error) {
+            this.logError((0, errorUtils_1.ensureError)(error), this.getErrorContext('subscribeToPrices', {
+                symbols: params.symbols?.join(','),
+            }));
+            // Return a no-op unsubscribe function
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+    }
+    /**
+     * Subscribe to live position updates
+     *
+     * @param params
+     */
+    subscribeToPositions(params) {
+        try {
+            const provider = this.getActiveProvider();
+            return provider.subscribeToPositions(params);
+        }
+        catch (error) {
+            this.logError((0, errorUtils_1.ensureError)(error), this.getErrorContext('subscribeToPositions', {
+                accountId: params.accountId,
+            }));
+            // Return a no-op unsubscribe function
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+    }
+    /**
+     * Subscribe to live order fill updates
+     *
+     * @param params
+     */
+    subscribeToOrderFills(params) {
+        try {
+            const provider = this.getActiveProvider();
+            return provider.subscribeToOrderFills(params);
+        }
+        catch (error) {
+            this.logError((0, errorUtils_1.ensureError)(error), this.getErrorContext('subscribeToOrderFills', {
+                accountId: params.accountId,
+            }));
+            // Return a no-op unsubscribe function
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+    }
+    /**
+     * Subscribe to live order updates
+     *
+     * @param params
+     */
+    subscribeToOrders(params) {
+        try {
+            const provider = this.getActiveProvider();
+            return provider.subscribeToOrders(params);
+        }
+        catch (error) {
+            this.logError((0, errorUtils_1.ensureError)(error), this.getErrorContext('subscribeToOrders', {
+                accountId: params.accountId,
+            }));
+            // Return a no-op unsubscribe function
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+    }
+    /**
+     * Subscribe to live account updates
+     *
+     * @param params
+     */
+    subscribeToAccount(params) {
+        try {
+            const provider = this.getActiveProvider();
+            return provider.subscribeToAccount(params);
+        }
+        catch (error) {
+            this.logError((0, errorUtils_1.ensureError)(error), this.getErrorContext('subscribeToAccount', {
+                accountId: params.accountId,
+            }));
+            // Return a no-op unsubscribe function
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+    }
+    /**
+     * Subscribe to full order book updates with multiple depth levels
+     * Creates a dedicated L2Book subscription for real-time order book data
+     *
+     * @param params
+     */
+    subscribeToOrderBook(params) {
+        try {
+            const provider = this.getActiveProvider();
+            return provider.subscribeToOrderBook(params);
+        }
+        catch (error) {
+            this.logError((0, errorUtils_1.ensureError)(error), this.getErrorContext('subscribeToOrderBook', {
+                symbol: params.symbol,
+                levels: params.levels,
+            }));
+            // Return a no-op unsubscribe function
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+    }
+    /**
+     * Subscribe to live candle updates
+     *
+     * @param params
+     */
+    subscribeToCandles(params) {
+        try {
+            const provider = this.getActiveProvider();
+            return provider.subscribeToCandles(params);
+        }
+        catch (error) {
+            this.logError((0, errorUtils_1.ensureError)(error), this.getErrorContext('subscribeToCandles', {
+                symbol: params.symbol,
+                interval: params.interval,
+                duration: params.duration,
+            }));
+            // Return a no-op unsubscribe function
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+    }
+    /**
+     * Subscribe to open interest cap updates
+     * Zero additional network overhead - data comes from existing webData3 subscription
+     *
+     * @param params
+     */
+    subscribeToOICaps(params) {
+        try {
+            const provider = this.getActiveProvider();
+            return provider.subscribeToOICaps(params);
+        }
+        catch (error) {
+            this.logError((0, errorUtils_1.ensureError)(error), this.getErrorContext('subscribeToOICaps', {
+                accountId: params.accountId,
+            }));
+            // Return a no-op unsubscribe function
+            return () => {
+                // No-op: Provider not initialized
+            };
+        }
+    }
+    /**
+     * Configure live data throttling
+     *
+     * @param config
+     */
+    setLiveDataConfig(config) {
+        try {
+            const provider = this.getActiveProvider();
+            provider.setLiveDataConfig(config);
+        }
+        catch (error) {
+            this.logError((0, errorUtils_1.ensureError)(error), this.getErrorContext('setLiveDataConfig'));
+        }
+    }
+    /**
+     * Calculate trading fees for the active provider
+     * Each provider implements its own fee structure
+     *
+     * @param params
+     */
+    async calculateFees(params) {
+        const provider = this.getActiveProvider();
+        const context = this.createServiceContext('calculateFees');
+        return this.marketDataService.calculateFees({ provider, params, context });
+    }
+    /**
+     * Disconnect provider and cleanup subscriptions
+     * Call this when navigating away from Perps screens to prevent battery drain
+     */
+    async disconnect() {
+        this.debugLog('PerpsController: Disconnecting provider to cleanup subscriptions', {
+            timestamp: new Date().toISOString(),
         });
+        // Only disconnect the provider if we're initialized
+        if (this.isInitialized && !this.isReinitializing) {
+            try {
+                const provider = this.getActiveProvider();
+                await provider.disconnect();
+            }
+            catch (error) {
+                this.logError((0, errorUtils_1.ensureError)(error), this.getErrorContext('disconnect'));
+            }
+        }
+        // Reset initialization state to ensure proper reconnection
+        this.isInitialized = false;
+        this.initializationPromise = null;
+    }
+    /**
+     * 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 = this.blockedRegionListVersion;
+        try {
+            // TODO: It would be good to have this location before we call this async function to avoid the race condition
+            const isEligible = await this.eligibilityService.checkEligibility(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 (this.blockedRegionListVersion !== versionAtStart) {
+                return;
+            }
+            this.update((state) => {
+                state.isEligible = isEligible;
+            });
+        }
+        catch (error) {
+            this.logError((0, errorUtils_1.ensureError)(error), this.getErrorContext('refreshEligibility'));
+            // Only update on error if version is still current
+            if (this.blockedRegionListVersion === 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 this.marketDataService.getBlockExplorerUrl({ provider, address });
+    }
+    /**
+     * Check if user is first-time for the current network
+     */
+    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';
+        this.debugLog('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';
+        this.debugLog('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() {
+        this.debugLog('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() {
+        this.debugLog('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
+     */
+    getTradeConfiguration(symbol) {
+        const network = this.state.isTestnet ? 'testnet' : 'mainnet';
+        const config = this.state.tradeConfigurations[network]?.[symbol];
+        if (!config?.leverage) {
+            return undefined;
+        }
+        this.debugLog('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';
+        this.debugLog('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
+     * @param config.amount
+     * @param config.leverage
+     * @param config.takeProfitPrice
+     * @param config.stopLossPrice
+     * @param config.limitPrice
+     * @param config.orderType
+     */
+    savePendingTradeConfiguration(symbol, config) {
+        const network = this.state.isTestnet ? 'testnet' : 'mainnet';
+        this.debugLog('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) {
+            this.debugLog('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;
+        }
+        this.debugLog('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';
+        this.debugLog('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
+     */
+    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: perpsConfig_1.MARKET_SORTING_CONFIG.DefaultDirection,
+            };
+        }
+        // Return new object format or default
+        return (pref ?? {
+            optionId: perpsConfig_1.MARKET_SORTING_CONFIG.DefaultSortOptionId,
+            direction: perpsConfig_1.MARKET_SORTING_CONFIG.DefaultDirection,
+        });
+    }
+    /**
+     * Save market filter preferences
+     *
+     * @param optionId - Sort/filter option ID
+     * @param direction - Sort direction ('asc' or 'desc')
+     */
+    saveMarketFilterPreferences(optionId, direction) {
+        this.debugLog('PerpsController: Saving market filter preferences', {
+            optionId,
+            direction,
+            timestamp: new Date().toISOString(),
+        });
+        this.update((state) => {
+            state.marketFilterPreferences = { optionId, direction };
+        });
+    }
+    /**
+     * 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) {
+            this.debugLog('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';
+        this.debugLog('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
+     */
+    toggleWatchlistMarket(symbol) {
+        const currentNetwork = this.state.isTestnet ? 'testnet' : 'mainnet';
+        const currentWatchlist = this.state.watchlistMarkets[currentNetwork];
+        const isWatchlisted = currentWatchlist.includes(symbol);
+        this.debugLog('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((s) => s !== symbol);
+            }
+            else {
+                // Add to watchlist
+                state.watchlistMarkets[currentNetwork] = [...currentWatchlist, symbol];
+            }
+        });
+    }
+    /**
+     * Check if a market is in the watchlist on the current network
+     *
+     * @param symbol
+     */
+    isWatchlistMarket(symbol) {
+        const currentNetwork = this.state.isTestnet ? 'testnet' : 'mainnet';
+        return this.state.watchlistMarkets[currentNetwork].includes(symbol);
+    }
+    /**
+     * Get all watchlist markets for the current network
+     */
+    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
+     * @param params.action
+     * @param params.symbol
+     * @param params.sl_price
+     * @param params.tp_price
+     * @param params.retryCount
+     * @param params._traceId
+     */
+    async reportOrderToDataLake(params) {
+        return this.dataLakeService.reportOrder({
+            action: params.action,
+            symbol: params.symbol,
+            sl_price: params.sl_price,
+            tp_price: params.tp_price,
+            isTestnet: this.state.isTestnet,
+            context: this.createServiceContext('reportOrderToDataLake', {
+                messenger: this.messenger,
+            }),
+            retryCount: params.retryCount,
+            _traceId: params._traceId,
+        });
+    }
+    /**
+     * Check if the controller is currently reinitializing
+     *
+     * @returns true if providers are being reinitialized
+     */
+    isCurrentlyReinitializing() {
+        return this.isReinitializing;
     }
 }
 exports.PerpsController = PerpsController;