@metamask-previews/perps-controller 0.0.0-preview-e4aa1532 → 0.0.0-preview-6dfa4aeba

package/dist/PerpsController.mjs

@@ -1,2240 +1,83 @@
-// 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 */
 import { BaseController } from "@metamask/base-controller";
-import { TransactionType } from "@metamask/transaction-controller";
-import { PerpsEventProperties, PerpsEventValues } from "./constants/eventNames.mjs";
-import { ARBITRUM_MAINNET_CHAIN_ID_HEX, USDC_ARBITRUM_MAINNET_ADDRESS, USDC_SYMBOL } from "./constants/hyperLiquidConfig.mjs";
-import { PERPS_CONSTANTS, MARKET_SORTING_CONFIG } from "./constants/perpsConfig.mjs";
-import { PERPS_ERROR_CODES } from "./constants/perpsErrorCodes.mjs";
-import { AggregatedPerpsProvider } from "./providers/AggregatedPerpsProvider.mjs";
-import { HyperLiquidProvider } from "./providers/HyperLiquidProvider.mjs";
-import { AccountService } from "./services/AccountService.mjs";
-import { DataLakeService } from "./services/DataLakeService.mjs";
-import { DepositService } from "./services/DepositService.mjs";
-import { EligibilityService } from "./services/EligibilityService.mjs";
-import { FeatureFlagConfigurationService } from "./services/FeatureFlagConfigurationService.mjs";
-import { MarketDataService } from "./services/MarketDataService.mjs";
-import { RewardsIntegrationService } from "./services/RewardsIntegrationService.mjs";
-import { TradingService } from "./services/TradingService.mjs";
-import { WebSocketConnectionState } from "./types/index.mjs";
-import { PerpsAnalyticsEvent } from "./types/index.mjs";
-import { CandlePeriod } from "./types/chart.mjs";
-import { ensureError } from "./utils/errorUtils.mjs";
-import { wait } from "./utils/wait.mjs";
-// Re-export error codes from separate file to avoid circular dependencies
-export { PERPS_ERROR_CODES } from "./constants/perpsErrorCodes.mjs";
 /**
- * Initialization state enum for state machine tracking
+ * 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.
  */
-export var InitializationState;
-(function (InitializationState) {
-    InitializationState["Uninitialized"] = "uninitialized";
-    InitializationState["Initializing"] = "initializing";
-    InitializationState["Initialized"] = "initialized";
-    InitializationState["Failed"] = "failed";
-})(InitializationState || (InitializationState = {}));
+export const controllerName = 'PerpsController';
 /**
- * Get default PerpsController state
- *
- * To change the active provider, modify the `activeProvider` value below:
- * - 'hyperliquid': HyperLiquid provider (default, production)
- * - 'aggregated': Multi-provider aggregation mode
- * - 'myx': MYX provider (future implementation)
+ * The metadata for each property in {@link PerpsControllerState}.
  */
-export const getDefaultPerpsControllerState = () => ({
-    activeProvider: 'hyperliquid',
-    isTestnet: false, // Default to mainnet
-    initializationState: InitializationState.Uninitialized,
-    initializationError: null,
-    initializationAttempts: 0,
-    accountState: null,
-    perpsBalances: {},
-    depositInProgress: false,
-    lastDepositResult: null,
-    withdrawInProgress: false,
-    lastDepositTransactionId: null,
-    lastWithdrawResult: null,
-    withdrawalRequests: [],
-    withdrawalProgress: {
-        progress: 0,
-        lastUpdated: 0,
-        activeWithdrawalId: null,
-    },
-    depositRequests: [],
-    lastError: null,
-    lastUpdateTimestamp: 0,
-    isEligible: false,
-    isFirstTimeUser: {
-        testnet: true,
-        mainnet: true,
-    },
-    hasPlacedFirstOrder: {
-        testnet: false,
-        mainnet: false,
-    },
-    watchlistMarkets: {
-        testnet: [],
-        mainnet: [],
-    },
-    tradeConfigurations: {
-        testnet: {},
-        mainnet: {},
-    },
-    marketFilterPreferences: {
-        optionId: MARKET_SORTING_CONFIG.DefaultSortOptionId,
-        direction: MARKET_SORTING_CONFIG.DefaultDirection,
-    },
-    hip3ConfigVersion: 0,
-});
+const perpsControllerMetadata = {};
 /**
- * State metadata for the PerpsController
+ * 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.
+ *
+ * @returns The default {@link PerpsController} state.
  */
-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,
-    },
-};
+export function getDefaultPerpsControllerState() {
+    return {};
+}
 /**
- * PerpsController - Protocol-agnostic perpetuals trading controller
+ * `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,
+ * });
  *
- * 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
+ * const perpsControllerState = await rootMessenger.call(
+ *   'PerpsController:getState',
+ * );
+ * ```
  */
 export class PerpsController extends BaseController {
-    constructor({ messenger, state = {}, clientConfig = {}, infrastructure, }) {
-        super({
-            name: 'PerpsController',
-            metadata,
-            messenger,
-            state: { ...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(infrastructure);
-        this.marketDataService = new MarketDataService(infrastructure);
-        this.accountService = new AccountService(infrastructure);
-        this.eligibilityService = new EligibilityService(infrastructure);
-        this.dataLakeService = new DataLakeService(infrastructure);
-        this.depositService = new DepositService(infrastructure);
-        this.featureFlagConfigurationService = new FeatureFlagConfigurationService(infrastructure);
-        this.rewardsIntegrationService = new 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(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.
-    // ============================================================================
-    /**
-     * Log an error using injected infrastructure logger
-     *
-     * @param error
-     * @param options
-     */
-    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(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(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({
-                    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({
-                        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 wait(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 = 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 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: 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 = PERPS_ERROR_CODES.CLIENT_REINITIALIZING;
-                state.lastUpdateTimestamp = Date.now();
-            });
-            throw new Error(PERPS_ERROR_CODES.CLIENT_REINITIALIZING);
-        }
-        // Check if not initialized
-        if (this.state.initializationState !== InitializationState.Initialized ||
-            !this.isInitialized) {
-            const errorMessage = this.state.initializationState === InitializationState.Failed
-                ? `${PERPS_ERROR_CODES.CLIENT_NOT_INITIALIZED}: ${this.state.initializationError || 'Initialization failed'}`
-                : PERPS_ERROR_CODES.CLIENT_NOT_INITIALIZED;
-            this.update((state) => {
-                state.lastError = errorMessage;
-                state.lastUpdateTimestamp = Date.now();
-            });
-            throw new Error(errorMessage);
-        }
-        // Return the active provider instance (set during initialization based on providerMode)
-        if (!this.activeProviderInstance) {
-            this.update((state) => {
-                state.lastError = PERPS_ERROR_CODES.PROVIDER_NOT_AVAILABLE;
-                state.lastUpdateTimestamp = Date.now();
-            });
-            throw new Error(PERPS_ERROR_CODES.PROVIDER_NOT_AVAILABLE);
-        }
-        return this.activeProviderInstance;
-    }
-    /**
-     * Get the currently active provider, returning null if not available
-     * Use this method when the caller can gracefully handle a missing provider
-     * (e.g., UI components during initialization or reconnection)
-     *
-     * @returns The active provider, or null if not initialized/reinitializing
-     */
-    getActiveProviderOrNull() {
-        // Return null during reinitialization
-        if (this.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
+     * Constructs a new {@link PerpsController}.
      *
-     * @param params
+     * @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.
      */
-    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: 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() === ARBITRUM_MAINNET_CHAIN_ID_HEX &&
-                transaction.to.toLowerCase() ===
-                    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: 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: 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: 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(PerpsAnalyticsEvent.WithdrawalTransaction, {
-                        [PerpsEventProperties.STATUS]: status === 'completed'
-                            ? PerpsEventValues.STATUS.COMPLETED
-                            : PerpsEventValues.STATUS.FAILED,
-                        [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' });
+    constructor({ messenger, state, }) {
+        super({
+            messenger,
+            metadata: perpsControllerMetadata,
+            name: controllerName,
+            state: {
+                ...getDefaultPerpsControllerState(),
+                ...state,
             },
         });
     }
-    /**
-     * 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({
-                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(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: 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
-                    : 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 WebSocketConnectionState.Disconnected;
-        }
-        catch {
-            // If no provider is active, return disconnected
-            return WebSocketConnectionState.Disconnected;
-        }
-    }
-    /**
-     * Subscribe to WebSocket connection state changes from the active provider.
-     * The listener will be called immediately with the current state and whenever the state changes.
-     *
-     * @param listener - Callback function that receives the new connection state and reconnection attempt
-     * @returns Unsubscribe function to remove the listener, or no-op if not supported
-     */
-    subscribeToConnectionState(listener) {
-        try {
-            const provider = this.getActiveProvider();
-            if (provider.subscribeToConnectionState) {
-                return provider.subscribeToConnectionState(listener);
-            }
-            // Fallback: immediately call with current state and return no-op unsubscribe
-            listener(this.getWebSocketConnectionState(), 0);
-            return () => {
-                // No-op
-            };
-        }
-        catch {
-            // If no provider is active, call with disconnected and return no-op
-            listener(WebSocketConnectionState.Disconnected, 0);
-            return () => {
-                // No-op
-            };
-        }
-    }
-    /**
-     * Manually trigger a WebSocket reconnection attempt.
-     * Used by the UI retry button when connection is lost.
-     */
-    async reconnect() {
-        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(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(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(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(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(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(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(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(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(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(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(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(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: MARKET_SORTING_CONFIG.DefaultDirection,
-            };
-        }
-        // Return new object format or default
-        return (pref ?? {
-            optionId: MARKET_SORTING_CONFIG.DefaultSortOptionId,
-            direction: MARKET_SORTING_CONFIG.DefaultDirection,
-        });
-    }
-    /**
-     * Save market filter preferences
-     *
-     * @param optionId - Sort/filter option ID
-     * @param direction - Sort direction ('asc' or 'desc')
-     */
-    saveMarketFilterPreferences(optionId, direction) {
-        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;
-    }
 }
 //# sourceMappingURL=PerpsController.mjs.map