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

package/dist/services/TradingService.mjs

@@ -1,1477 +0,0 @@
-/* eslint-disable id-denylist, jsdoc/require-param-description, @typescript-eslint/prefer-nullish-coalescing, no-restricted-syntax, @typescript-eslint/naming-convention, @typescript-eslint/unbound-method, no-eq-null, jsdoc/check-param-names */
-// TODO: Fix ESLint errors in this file - tracked for Phase 5 cleanup
-import { v4 as uuidv4 } from "uuid";
-import { PerpsEventProperties, PerpsEventValues } from "../constants/eventNames.mjs";
-import { isTPSLOrder } from "../constants/orderTypes.mjs";
-import { PerpsMeasurementName } from "../constants/performanceMetrics.mjs";
-import { PerpsAnalyticsEvent, PerpsTraceNames, PerpsTraceOperations } from "../types/index.mjs";
-/**
- * TradingService
- *
- * Handles trading operations with fee discount management.
- * Controller is responsible for analytics, state management, and tracing.
- *
- * Instance-based service with constructor injection of platform dependencies.
- * Controller-level dependencies (RewardsController, NetworkController, etc.)
- * are injected via setControllerDependencies() after construction.
- */
-export class TradingService {
-    /**
-     * Create a new TradingService instance.
-     *
-     * @param deps - Platform dependencies for logging, metrics, etc.
-     */
-    constructor(deps) {
-        /**
-         * Controller-level dependencies for fee discount calculation.
-         * Set via setControllerDependencies() after construction.
-         */
-        this.controllerDeps = null;
-        this.deps = deps;
-    }
-    /**
-     * Set controller-level dependencies for fee discount calculation.
-     * Called by PerpsController after construction to inject singleton dependencies.
-     *
-     * @param controllerDeps - Controller-level dependencies (RewardsController, etc.)
-     */
-    setControllerDependencies(controllerDeps) {
-        this.controllerDeps = controllerDeps;
-    }
-    /**
-     * Error context helper for consistent logging.
-     *
-     * @param method - Method name
-     * @param additionalContext - Additional context data
-     * @returns Error context object
-     */
-    getErrorContext(method, additionalContext) {
-        return {
-            controller: 'TradingService',
-            method,
-            ...additionalContext,
-        };
-    }
-    /**
-     * Track order result analytics event (success or failure).
-     *
-     * @param options - Tracking options
-     * @param options.result
-     * @param options.error
-     * @param options.params
-     * @param options.context
-     * @param options.duration
-     */
-    trackOrderResult(options) {
-        const { result, error, params, duration } = options;
-        const status = result?.success === true
-            ? PerpsEventValues.STATUS.EXECUTED
-            : PerpsEventValues.STATUS.FAILED;
-        // Build base properties
-        const properties = {
-            [PerpsEventProperties.STATUS]: status,
-            [PerpsEventProperties.ASSET]: params.symbol,
-            [PerpsEventProperties.DIRECTION]: params.isBuy
-                ? PerpsEventValues.DIRECTION.LONG
-                : PerpsEventValues.DIRECTION.SHORT,
-            [PerpsEventProperties.ORDER_TYPE]: params.orderType,
-            [PerpsEventProperties.LEVERAGE]: parseFloat(String(params.leverage || 1)),
-            [PerpsEventProperties.ORDER_SIZE]: parseFloat(result?.filledSize || params.size),
-            [PerpsEventProperties.COMPLETION_DURATION]: duration,
-        };
-        // Add optional properties
-        if (params.trackingData?.marginUsed != null) {
-            properties[PerpsEventProperties.MARGIN_USED] =
-                params.trackingData.marginUsed;
-        }
-        if (params.trackingData?.totalFee != null) {
-            properties[PerpsEventProperties.FEES] = params.trackingData.totalFee;
-        }
-        if (result?.averagePrice || params.trackingData?.marketPrice) {
-            properties[PerpsEventProperties.ASSET_PRICE] = result?.averagePrice
-                ? parseFloat(result.averagePrice)
-                : params.trackingData?.marketPrice;
-        }
-        if (params.orderType === 'limit' && params.price) {
-            properties[PerpsEventProperties.LIMIT_PRICE] = parseFloat(params.price);
-        }
-        if (params.trackingData?.source) {
-            properties[PerpsEventProperties.SOURCE] = params.trackingData.source;
-        }
-        if (params.trackingData?.tradeAction) {
-            properties[PerpsEventProperties.ACTION] = params.trackingData.tradeAction;
-        }
-        // Add success-specific properties
-        if (status === PerpsEventValues.STATUS.EXECUTED) {
-            if (params.trackingData?.metamaskFee != null) {
-                properties[PerpsEventProperties.METAMASK_FEE] =
-                    params.trackingData.metamaskFee;
-            }
-            if (params.trackingData?.metamaskFeeRate != null) {
-                properties[PerpsEventProperties.METAMASK_FEE_RATE] =
-                    params.trackingData.metamaskFeeRate;
-            }
-            if (params.trackingData?.feeDiscountPercentage != null) {
-                properties[PerpsEventProperties.DISCOUNT_PERCENTAGE] =
-                    params.trackingData.feeDiscountPercentage;
-            }
-            if (params.trackingData?.estimatedPoints != null) {
-                properties[PerpsEventProperties.ESTIMATED_REWARDS] =
-                    params.trackingData.estimatedPoints;
-            }
-            if (params.takeProfitPrice) {
-                properties[PerpsEventProperties.TAKE_PROFIT_PRICE] = parseFloat(params.takeProfitPrice);
-            }
-            if (params.stopLossPrice) {
-                properties[PerpsEventProperties.STOP_LOSS_PRICE] = parseFloat(params.stopLossPrice);
-            }
-        }
-        else {
-            // Add failure-specific properties
-            properties[PerpsEventProperties.ERROR_MESSAGE] =
-                error?.message || result?.error || 'Unknown error';
-        }
-        this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.TradeTransaction, properties);
-    }
-    /**
-     * Handle successful order placement (state updates, analytics, data lake reporting).
-     *
-     * @param options - Options for handling order success
-     * @param options.params
-     * @param options.context
-     * @param options.reportOrderToDataLake
-     */
-    async handleOrderSuccess(options) {
-        const { params, context, reportOrderToDataLake } = options;
-        // Update state on success
-        if (context.stateManager) {
-            context.stateManager.update((state) => {
-                state.lastUpdateTimestamp = Date.now();
-            });
-        }
-        // Save executed trade configuration for this market
-        if (params.leverage && context.saveTradeConfiguration) {
-            context.saveTradeConfiguration(params.symbol, params.leverage);
-        }
-        // Report to data lake (fire-and-forget with retry)
-        reportOrderToDataLake({
-            action: 'open',
-            symbol: params.symbol,
-            sl_price: params.stopLossPrice
-                ? parseFloat(params.stopLossPrice)
-                : undefined,
-            tp_price: params.takeProfitPrice
-                ? parseFloat(params.takeProfitPrice)
-                : undefined,
-        }).catch((caughtError) => {
-            const errorObj = caughtError instanceof Error
-                ? caughtError
-                : new Error(String(caughtError));
-            this.deps.logger.error(errorObj, {
-                tags: {
-                    feature: 'perps',
-                    provider: context.tracingContext.provider,
-                    network: context.tracingContext.isTestnet ? 'testnet' : 'mainnet',
-                },
-                context: {
-                    name: context.errorContext.controller,
-                    data: {
-                        method: context.errorContext.method,
-                        operation: 'reportOrderToDataLake',
-                        symbol: params.symbol,
-                    },
-                },
-            });
-        });
-    }
-    /**
-     * Execute a trading operation with fee discount context.
-     * Ensures fee discount is always cleared after operation (success or failure).
-     *
-     * @param options - Options for fee discount context
-     * @param options.provider
-     * @param options.feeDiscountBips
-     * @param options.operation
-     * @returns The operation result
-     */
-    async withFeeDiscount(options) {
-        const { provider, feeDiscountBips, operation } = options;
-        try {
-            // Set discount context in provider for this operation
-            if (feeDiscountBips !== undefined && provider.setUserFeeDiscount) {
-                provider.setUserFeeDiscount(feeDiscountBips);
-                this.deps.debugLogger.log('TradingService: Fee discount set in provider', {
-                    feeDiscountBips,
-                });
-            }
-            // Execute the operation
-            return await operation();
-        }
-        finally {
-            // Always clear discount context, even on exception
-            if (provider.setUserFeeDiscount) {
-                provider.setUserFeeDiscount(undefined);
-                this.deps.debugLogger.log('TradingService: Fee discount cleared from provider');
-            }
-        }
-    }
-    /**
-     * Place a new order with full orchestration.
-     * Handles tracing, fee discounts, state management, analytics, and data lake reporting.
-     *
-     * @param options - Options for placing order
-     * @param options.provider
-     * @param options.params
-     * @param options.context
-     * @param options.reportOrderToDataLake
-     * @returns Order result
-     */
-    async placeOrder(options) {
-        const { provider, params, context, reportOrderToDataLake } = options;
-        const traceId = uuidv4();
-        const startTime = this.deps.performance.now();
-        let traceData;
-        try {
-            // Start trace for the entire operation
-            this.deps.tracer.trace({
-                name: PerpsTraceNames.PlaceOrder,
-                id: traceId,
-                op: PerpsTraceOperations.OrderSubmission,
-                tags: {
-                    provider: context.tracingContext.provider,
-                    orderType: params.orderType,
-                    market: params.symbol,
-                    leverage: String(params.leverage || 1),
-                    isTestnet: String(context.tracingContext.isTestnet),
-                },
-                data: {
-                    isBuy: params.isBuy,
-                    orderPrice: params.price || '',
-                },
-            });
-            // Calculate fee discount at execution time (fresh, secure)
-            const feeDiscountBips = await this.calculateFeeDiscountWithMeasurement();
-            this.deps.debugLogger.log('TradingService: Fee discount calculated', {
-                feeDiscountBips,
-                hasDiscount: feeDiscountBips !== undefined,
-            });
-            this.deps.debugLogger.log('TradingService: Submitting order to provider', {
-                symbol: params.symbol,
-                orderType: params.orderType,
-                isBuy: params.isBuy,
-                size: params.size,
-                leverage: params.leverage,
-                hasTP: Boolean(params.takeProfitPrice),
-                hasSL: Boolean(params.stopLossPrice),
-            });
-            // Execute order with fee discount management
-            const result = await this.withFeeDiscount({
-                provider,
-                feeDiscountBips,
-                operation: () => provider.placeOrder(params),
-            });
-            this.deps.debugLogger.log('TradingService: Provider response received', {
-                success: result.success,
-                orderId: result.orderId,
-                error: result.error,
-            });
-            // Update state and handle success/failure
-            const completionDuration = this.deps.performance.now() - startTime;
-            if (result.success) {
-                // Handle success: state updates, data lake reporting
-                await this.handleOrderSuccess({
-                    params,
-                    context,
-                    reportOrderToDataLake,
-                });
-                traceData = { success: true, orderId: result.orderId || '' };
-            }
-            else {
-                traceData = { success: false, error: result.error || 'Unknown error' };
-            }
-            // Track analytics (success or failure)
-            this.trackOrderResult({
-                result,
-                params,
-                context,
-                duration: completionDuration,
-            });
-            return result;
-        }
-        catch (err) {
-            const completionDuration = this.deps.performance.now() - startTime;
-            const error = err instanceof Error ? err : new Error(String(err));
-            // Track analytics for exception
-            this.trackOrderResult({
-                result: null,
-                error,
-                params,
-                context,
-                duration: completionDuration,
-            });
-            this.deps.logger.error(error, {
-                tags: {
-                    feature: 'perps',
-                    provider: context.tracingContext.provider,
-                    network: context.tracingContext.isTestnet ? 'testnet' : 'mainnet',
-                },
-                context: {
-                    name: context.errorContext.controller,
-                    data: {
-                        method: context.errorContext.method,
-                        symbol: params.symbol,
-                        orderType: params.orderType,
-                    },
-                },
-            });
-            traceData = {
-                success: false,
-                error: error.message,
-            };
-            throw err;
-        }
-        finally {
-            // Always end trace on exit (success or failure)
-            this.deps.tracer.endTrace({
-                name: PerpsTraceNames.PlaceOrder,
-                id: traceId,
-                data: traceData,
-            });
-        }
-    }
-    /**
-     * Load position data with performance measurement.
-     *
-     * @param options - Options for loading position data
-     * @param options.symbol
-     * @param options.context
-     * @returns The position or undefined
-     */
-    async loadPositionData(options) {
-        const { symbol, context } = options;
-        const positionLoadStart = this.deps.performance.now();
-        try {
-            const positions = context.getPositions
-                ? await context.getPositions()
-                : [];
-            const position = positions.find((pos) => pos.symbol === symbol);
-            this.deps.tracer.setMeasurement(PerpsMeasurementName.PerpsGetPositionsOperation, this.deps.performance.now() - positionLoadStart, 'millisecond');
-            return position;
-        }
-        catch (err) {
-            this.deps.debugLogger.log('TradingService: Could not get position data for tracking', err instanceof Error ? err.message : String(err));
-            return undefined;
-        }
-    }
-    /**
-     * Calculate close position metrics.
-     *
-     * @param position - The position being closed
-     * @param params - Close position parameters
-     * @param result - Order result
-     * @returns Calculated metrics
-     */
-    calculateCloseMetrics(position, params, result) {
-        const direction = parseFloat(position.size) > 0
-            ? PerpsEventValues.DIRECTION.LONG
-            : PerpsEventValues.DIRECTION.SHORT;
-        const filledSize = result.filledSize ? parseFloat(result.filledSize) : 0;
-        const requestedSize = params.size
-            ? parseFloat(params.size)
-            : Math.abs(parseFloat(position.size));
-        const isPartiallyFilled = filledSize > 0 && filledSize < requestedSize;
-        const orderType = params.orderType || PerpsEventValues.ORDER_TYPE.MARKET;
-        const closePercentage = params.size
-            ? (parseFloat(params.size) / Math.abs(parseFloat(position.size))) * 100
-            : 100;
-        const closeType = closePercentage === 100
-            ? PerpsEventValues.CLOSE_TYPE.FULL
-            : PerpsEventValues.CLOSE_TYPE.PARTIAL;
-        return {
-            direction,
-            closePercentage,
-            closeType,
-            orderType,
-            filledSize,
-            requestedSize,
-            isPartiallyFilled,
-        };
-    }
-    /**
-     * Build event properties for position close analytics.
-     *
-     * @param position - The position being closed
-     * @param params - Close position parameters
-     * @param metrics - Calculated metrics
-     * @param metrics.direction
-     * @param result - Order result
-     * @param metrics.closePercentage
-     * @param status - Event status
-     * @param metrics.closeType
-     * @param error - Error message if any
-     * @param metrics.orderType
-     * @param metrics.requestedSize
-     * @returns Event properties
-     */
-    buildCloseEventProperties(position, params, metrics, result, status, error) {
-        const baseProperties = {
-            [PerpsEventProperties.STATUS]: status,
-            [PerpsEventProperties.ASSET]: position.symbol,
-            [PerpsEventProperties.DIRECTION]: metrics.direction,
-            [PerpsEventProperties.ORDER_TYPE]: metrics.orderType,
-            [PerpsEventProperties.ORDER_SIZE]: metrics.requestedSize,
-            [PerpsEventProperties.OPEN_POSITION_SIZE]: Math.abs(parseFloat(position.size)),
-            [PerpsEventProperties.PERCENTAGE_CLOSED]: metrics.closePercentage,
-            ...(position.unrealizedPnl && {
-                [PerpsEventProperties.PNL_DOLLAR]: parseFloat(position.unrealizedPnl),
-            }),
-            ...(position.returnOnEquity && {
-                [PerpsEventProperties.PNL_PERCENT]: parseFloat(position.returnOnEquity) * 100,
-            }),
-            ...(params.trackingData?.totalFee != null && {
-                [PerpsEventProperties.FEE]: params.trackingData.totalFee,
-            }),
-            ...(params.trackingData?.metamaskFee != null && {
-                [PerpsEventProperties.METAMASK_FEE]: params.trackingData.metamaskFee,
-            }),
-            ...(params.trackingData?.metamaskFeeRate != null && {
-                [PerpsEventProperties.METAMASK_FEE_RATE]: params.trackingData.metamaskFeeRate,
-            }),
-            ...(params.trackingData?.feeDiscountPercentage != null && {
-                [PerpsEventProperties.DISCOUNT_PERCENTAGE]: params.trackingData.feeDiscountPercentage,
-            }),
-            ...(params.trackingData?.estimatedPoints != null && {
-                [PerpsEventProperties.ESTIMATED_REWARDS]: params.trackingData.estimatedPoints,
-            }),
-            ...((params.trackingData?.marketPrice || result?.averagePrice) && {
-                [PerpsEventProperties.ASSET_PRICE]: result?.averagePrice
-                    ? parseFloat(result.averagePrice)
-                    : params.trackingData?.marketPrice,
-            }),
-            ...(params.orderType === 'limit' &&
-                params.price && {
-                [PerpsEventProperties.LIMIT_PRICE]: parseFloat(params.price),
-            }),
-            ...(params.trackingData?.receivedAmount != null && {
-                [PerpsEventProperties.RECEIVED_AMOUNT]: params.trackingData.receivedAmount,
-            }),
-        };
-        // Add success-specific properties
-        if (status === PerpsEventValues.STATUS.EXECUTED) {
-            return {
-                ...baseProperties,
-                [PerpsEventProperties.CLOSE_TYPE]: metrics.closeType,
-            };
-        }
-        // Add error for failures
-        return {
-            ...baseProperties,
-            ...(error && { [PerpsEventProperties.ERROR_MESSAGE]: error }),
-        };
-    }
-    /**
-     * Track position close result analytics (consolidates all tracking logic).
-     *
-     * @param options - Tracking options
-     * @param options.position
-     * @param options.result
-     * @param options.error
-     * @param options.params
-     * @param options.context
-     * @param options.duration
-     */
-    trackPositionCloseResult(options) {
-        const { position, result, error, params, duration } = options;
-        if (!position) {
-            return;
-        }
-        const metrics = result
-            ? this.calculateCloseMetrics(position, params, result)
-            : {
-                direction: parseFloat(position.size) > 0
-                    ? PerpsEventValues.DIRECTION.LONG
-                    : PerpsEventValues.DIRECTION.SHORT,
-                closePercentage: params.size
-                    ? (parseFloat(params.size) / Math.abs(parseFloat(position.size))) *
-                        100
-                    : 100,
-                closeType: PerpsEventValues.CLOSE_TYPE.FULL,
-                orderType: params.orderType || PerpsEventValues.ORDER_TYPE.MARKET,
-                requestedSize: params.size
-                    ? parseFloat(params.size)
-                    : Math.abs(parseFloat(position.size)),
-                filledSize: 0,
-                isPartiallyFilled: false,
-            };
-        // Track partially filled event if applicable
-        if (result?.success && metrics.isPartiallyFilled) {
-            const partialProperties = this.buildCloseEventProperties(position, params, metrics, result, PerpsEventValues.STATUS.PARTIALLY_FILLED);
-            this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.PositionCloseTransaction, {
-                ...partialProperties,
-                [PerpsEventProperties.AMOUNT_FILLED]: metrics.filledSize,
-                [PerpsEventProperties.REMAINING_AMOUNT]: metrics.requestedSize - metrics.filledSize,
-                [PerpsEventProperties.COMPLETION_DURATION]: duration,
-            });
-        }
-        // Determine status
-        const status = result?.success === true
-            ? PerpsEventValues.STATUS.EXECUTED
-            : PerpsEventValues.STATUS.FAILED;
-        const errorMessage = error?.message || result?.error;
-        // Track main close event
-        const eventProperties = this.buildCloseEventProperties(position, params, metrics, result, status, errorMessage);
-        this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.PositionCloseTransaction, {
-            ...eventProperties,
-            [PerpsEventProperties.COMPLETION_DURATION]: duration,
-        });
-    }
-    /**
-     * Handle data lake reporting (fire-and-forget).
-     *
-     * @param reportOrderToDataLake - Data lake reporting function
-     * @param symbol - Asset symbol
-     * @param context - Service context
-     */
-    handleDataLakeReporting(reportOrderToDataLake, symbol, context) {
-        reportOrderToDataLake({
-            action: 'close',
-            symbol,
-        }).catch((caughtError) => {
-            const errorObj = caughtError instanceof Error
-                ? caughtError
-                : new Error(String(caughtError));
-            this.deps.logger.error(errorObj, {
-                tags: {
-                    feature: 'perps',
-                    provider: context.tracingContext.provider,
-                    network: context.tracingContext.isTestnet ? 'testnet' : 'mainnet',
-                },
-                context: {
-                    name: context.errorContext.controller,
-                    data: {
-                        method: context.errorContext.method,
-                        operation: 'reportOrderToDataLake',
-                        symbol,
-                    },
-                },
-            });
-        });
-    }
-    /**
-     * Calculate fee discount with performance measurement.
-     * Uses controller dependencies injected via setControllerDependencies().
-     * Helper method for placeOrder orchestration.
-     *
-     * @returns Fee discount in basis points or undefined
-     */
-    async calculateFeeDiscountWithMeasurement() {
-        // Check if controller dependencies are available
-        if (!this.controllerDeps) {
-            this.deps.debugLogger.log('TradingService: Controller dependencies not set, skipping fee discount');
-            return undefined;
-        }
-        const { controllers, rewardsIntegrationService } = this.controllerDeps;
-        const orderExecutionFeeDiscountStartTime = this.deps.performance.now();
-        // Calculate fee discount using injected controllers
-        const discountBips = await rewardsIntegrationService.calculateUserFeeDiscount({
-            controllers,
-        });
-        const orderExecutionFeeDiscountDuration = this.deps.performance.now() - orderExecutionFeeDiscountStartTime;
-        // Record measurement
-        this.deps.tracer.setMeasurement(PerpsMeasurementName.PerpsRewardsOrderExecutionFeeDiscountApiCall, orderExecutionFeeDiscountDuration, 'millisecond');
-        this.deps.debugLogger.log('TradingService: Fee discount API call completed', {
-            discountBips,
-            duration: `${orderExecutionFeeDiscountDuration.toFixed(0)}ms`,
-        });
-        return discountBips;
-    }
-    /**
-     * Edit an existing order with full orchestration.
-     * Handles tracing, fee discounts, state management, and analytics.
-     *
-     * @param options - Options for editing order
-     * @param options.provider
-     * @param options.params
-     * @param options.context
-     * @returns Order result
-     */
-    async editOrder(options) {
-        const { provider, params, context } = options;
-        const traceId = uuidv4();
-        const startTime = this.deps.performance.now();
-        let traceData;
-        try {
-            this.deps.tracer.trace({
-                name: PerpsTraceNames.EditOrder,
-                id: traceId,
-                op: PerpsTraceOperations.OrderSubmission,
-                tags: {
-                    provider: context.tracingContext.provider,
-                    orderType: params.newOrder.orderType,
-                    market: params.newOrder.symbol,
-                    leverage: String(params.newOrder.leverage || 1),
-                    isTestnet: String(context.tracingContext.isTestnet),
-                },
-                data: {
-                    isBuy: params.newOrder.isBuy,
-                    orderPrice: params.newOrder.price || '',
-                },
-            });
-            // Calculate fee discount only if required dependencies are available
-            const feeDiscountBips = await this.calculateFeeDiscountWithMeasurement();
-            // Execute order edit with fee discount management
-            const result = await this.withFeeDiscount({
-                provider,
-                feeDiscountBips,
-                operation: () => provider.editOrder(params),
-            });
-            const completionDuration = this.deps.performance.now() - startTime;
-            if (result.success) {
-                // Update state on success
-                if (context.stateManager) {
-                    context.stateManager.update((state) => {
-                        state.lastUpdateTimestamp = Date.now();
-                    });
-                }
-                // Track order edit executed
-                const editExecutedProps = {
-                    [PerpsEventProperties.STATUS]: PerpsEventValues.STATUS.EXECUTED,
-                    [PerpsEventProperties.ASSET]: params.newOrder.symbol,
-                    [PerpsEventProperties.DIRECTION]: params.newOrder.isBuy
-                        ? PerpsEventValues.DIRECTION.LONG
-                        : PerpsEventValues.DIRECTION.SHORT,
-                    [PerpsEventProperties.ORDER_TYPE]: params.newOrder.orderType,
-                    [PerpsEventProperties.LEVERAGE]: params.newOrder.leverage || 1,
-                    [PerpsEventProperties.ORDER_SIZE]: params.newOrder.size,
-                    [PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
-                };
-                if (params.newOrder.price) {
-                    editExecutedProps[PerpsEventProperties.LIMIT_PRICE] = parseFloat(params.newOrder.price);
-                }
-                this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.TradeTransaction, editExecutedProps);
-                traceData = { success: true, orderId: result.orderId || '' };
-            }
-            else {
-                // Track order edit failed
-                this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.TradeTransaction, {
-                    [PerpsEventProperties.STATUS]: PerpsEventValues.STATUS.FAILED,
-                    [PerpsEventProperties.ASSET]: params.newOrder.symbol,
-                    [PerpsEventProperties.DIRECTION]: params.newOrder.isBuy
-                        ? PerpsEventValues.DIRECTION.LONG
-                        : PerpsEventValues.DIRECTION.SHORT,
-                    [PerpsEventProperties.ORDER_TYPE]: params.newOrder.orderType,
-                    [PerpsEventProperties.LEVERAGE]: params.newOrder.leverage || 1,
-                    [PerpsEventProperties.ORDER_SIZE]: params.newOrder.size,
-                    [PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
-                    [PerpsEventProperties.ERROR_MESSAGE]: result.error || 'Unknown error',
-                });
-                traceData = { success: false, error: result.error || 'Unknown error' };
-            }
-            return result;
-        }
-        catch (err) {
-            const completionDuration = this.deps.performance.now() - startTime;
-            const error = err instanceof Error ? err : new Error(String(err));
-            // Track order edit exception
-            this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.TradeTransaction, {
-                [PerpsEventProperties.STATUS]: PerpsEventValues.STATUS.FAILED,
-                [PerpsEventProperties.ASSET]: params.newOrder.symbol,
-                [PerpsEventProperties.DIRECTION]: params.newOrder.isBuy
-                    ? PerpsEventValues.DIRECTION.LONG
-                    : PerpsEventValues.DIRECTION.SHORT,
-                [PerpsEventProperties.ORDER_TYPE]: params.newOrder.orderType,
-                [PerpsEventProperties.LEVERAGE]: params.newOrder.leverage || 1,
-                [PerpsEventProperties.ORDER_SIZE]: params.newOrder.size,
-                [PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
-                [PerpsEventProperties.ERROR_MESSAGE]: error.message,
-            });
-            this.deps.logger.error(error, {
-                tags: {
-                    feature: 'perps',
-                    provider: context.tracingContext.provider,
-                    network: context.tracingContext.isTestnet ? 'testnet' : 'mainnet',
-                },
-                context: {
-                    name: context.errorContext.controller,
-                    data: {
-                        method: context.errorContext.method,
-                        orderId: params.orderId,
-                    },
-                },
-            });
-            traceData = {
-                success: false,
-                error: error.message,
-            };
-            throw err;
-        }
-        finally {
-            this.deps.tracer.endTrace({
-                name: PerpsTraceNames.EditOrder,
-                id: traceId,
-                data: traceData,
-            });
-        }
-    }
-    /**
-     * Cancel a single order with full orchestration.
-     * Handles tracing, state management, and analytics.
-     *
-     * @param options - Options for canceling order
-     * @param options.provider
-     * @param options.params
-     * @param options.context
-     * @returns Cancel order result
-     */
-    async cancelOrder(options) {
-        const { provider, params, context } = options;
-        const traceId = uuidv4();
-        const startTime = this.deps.performance.now();
-        let traceData;
-        try {
-            // Start trace for the entire operation
-            this.deps.tracer.trace({
-                name: PerpsTraceNames.CancelOrder,
-                id: traceId,
-                op: PerpsTraceOperations.OrderSubmission,
-                tags: {
-                    provider: context.tracingContext.provider,
-                    market: params.symbol,
-                    isTestnet: String(context.tracingContext.isTestnet),
-                },
-                data: {
-                    orderId: params.orderId,
-                },
-            });
-            // Execute order cancellation
-            const result = await provider.cancelOrder(params);
-            const completionDuration = this.deps.performance.now() - startTime;
-            if (result.success) {
-                // Update state on success
-                if (context.stateManager) {
-                    context.stateManager.update((state) => {
-                        state.lastUpdateTimestamp = Date.now();
-                    });
-                }
-                // Track order cancel executed
-                this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.OrderCancelTransaction, {
-                    [PerpsEventProperties.STATUS]: PerpsEventValues.STATUS.EXECUTED,
-                    [PerpsEventProperties.ASSET]: params.symbol,
-                    [PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
-                });
-                traceData = { success: true, orderId: params.orderId };
-            }
-            else {
-                // Track order cancel failed
-                this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.OrderCancelTransaction, {
-                    [PerpsEventProperties.STATUS]: PerpsEventValues.STATUS.FAILED,
-                    [PerpsEventProperties.ASSET]: params.symbol,
-                    [PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
-                    [PerpsEventProperties.ERROR_MESSAGE]: result.error || 'Unknown error',
-                });
-                traceData = { success: false, error: result.error || 'Unknown error' };
-            }
-            return result;
-        }
-        catch (err) {
-            const completionDuration = this.deps.performance.now() - startTime;
-            const error = err instanceof Error ? err : new Error(String(err));
-            // Track order cancel exception
-            this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.OrderCancelTransaction, {
-                [PerpsEventProperties.STATUS]: PerpsEventValues.STATUS.FAILED,
-                [PerpsEventProperties.ASSET]: params.symbol,
-                [PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
-                [PerpsEventProperties.ERROR_MESSAGE]: error.message,
-            });
-            this.deps.logger.error(error, this.getErrorContext('cancelOrder', { symbol: params.symbol }));
-            traceData = {
-                success: false,
-                error: error.message,
-            };
-            throw err;
-        }
-        finally {
-            this.deps.tracer.endTrace({
-                name: PerpsTraceNames.CancelOrder,
-                id: traceId,
-                data: traceData,
-            });
-        }
-    }
-    /**
-     * Cancel multiple orders with full orchestration.
-     * Handles tracing, stream pausing, filtering, batch operations, and analytics.
-     *
-     * @param options - Options for canceling multiple orders
-     * @param options.provider
-     * @param options.params
-     * @param options.context
-     * @param options.withStreamPause
-     * @returns Cancel orders result
-     */
-    async cancelOrders(options) {
-        const { provider, params, context, withStreamPause } = options;
-        const traceId = uuidv4();
-        const startTime = this.deps.performance.now();
-        let operationResult = null;
-        let operationError = null;
-        try {
-            // Start trace for batch operation
-            this.deps.tracer.trace({
-                name: PerpsTraceNames.CancelOrder,
-                id: traceId,
-                op: PerpsTraceOperations.OrderSubmission,
-                tags: {
-                    provider: context.tracingContext.provider,
-                    isBatch: 'true',
-                    isTestnet: String(context.tracingContext.isTestnet),
-                },
-                data: {
-                    cancelAll: params.cancelAll ? 'true' : 'false',
-                    symbolCount: params.symbols?.length || 0,
-                    orderIdCount: params.orderIds?.length || 0,
-                },
-            });
-            // Pause orders stream to prevent WebSocket updates during cancellation
-            operationResult = await withStreamPause(async () => {
-                // Get all open orders
-                if (!context.getOpenOrders) {
-                    throw new Error('getOpenOrders callback not provided in context');
-                }
-                const orders = await context.getOpenOrders();
-                // Filter orders based on params
-                let ordersToCancel = orders;
-                if (params.cancelAll || (!params.symbols && !params.orderIds)) {
-                    // Cancel all orders (excluding TP/SL orders for positions)
-                    ordersToCancel = orders.filter((order) => !isTPSLOrder(order.detailedOrderType));
-                }
-                else if (params.orderIds && params.orderIds.length > 0) {
-                    // Cancel specific order IDs
-                    ordersToCancel = orders.filter((order) => params.orderIds?.includes(order.orderId));
-                }
-                else if (params.symbols && params.symbols.length > 0) {
-                    // Cancel orders for specific symbols
-                    ordersToCancel = orders.filter((order) => params.symbols?.includes(order.symbol));
-                }
-                if (ordersToCancel.length === 0) {
-                    return {
-                        success: false,
-                        successCount: 0,
-                        failureCount: 0,
-                        results: [],
-                    };
-                }
-                // Use batch cancel if provider supports it
-                if (provider.cancelOrders) {
-                    return await provider.cancelOrders(ordersToCancel.map((order) => ({
-                        symbol: order.symbol,
-                        orderId: order.orderId,
-                    })));
-                }
-                // Fallback: Cancel orders in parallel (for providers without batch support)
-                const results = await Promise.allSettled(ordersToCancel.map((order) => this.cancelOrder({
-                    provider,
-                    params: { symbol: order.symbol, orderId: order.orderId },
-                    context,
-                })));
-                // Aggregate results
-                const successCount = results.filter((resItem) => resItem.status === 'fulfilled' && resItem.value.success).length;
-                const failureCount = results.length - successCount;
-                return {
-                    success: successCount > 0,
-                    successCount,
-                    failureCount,
-                    results: results.map((resItem, index) => {
-                        let errorMsg;
-                        if (resItem.status === 'rejected') {
-                            errorMsg =
-                                resItem.reason instanceof Error
-                                    ? resItem.reason.message
-                                    : 'Unknown error';
-                        }
-                        else if (resItem.status === 'fulfilled' &&
-                            !resItem.value.success) {
-                            errorMsg = resItem.value.error;
-                        }
-                        return {
-                            orderId: ordersToCancel[index].orderId,
-                            symbol: ordersToCancel[index].symbol,
-                            success: Boolean(resItem.status === 'fulfilled' && resItem.value.success),
-                            error: errorMsg,
-                        };
-                    }),
-                };
-            }, ['orders']); // Disconnect orders stream during operation
-            return operationResult;
-        }
-        catch (err) {
-            operationError = err instanceof Error ? err : new Error(String(err));
-            this.deps.logger.error(operationError, this.getErrorContext('cancelOrders'));
-            throw err;
-        }
-        finally {
-            const completionDuration = this.deps.performance.now() - startTime;
-            // Track batch cancel event (success or failure)
-            const batchCancelProps = {
-                [PerpsEventProperties.STATUS]: operationResult?.success && operationResult.successCount > 0
-                    ? PerpsEventValues.STATUS.EXECUTED
-                    : PerpsEventValues.STATUS.FAILED,
-                [PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
-            };
-            if (operationError) {
-                batchCancelProps[PerpsEventProperties.ERROR_MESSAGE] =
-                    operationError.message;
-            }
-            this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.OrderCancelTransaction, batchCancelProps);
-            this.deps.tracer.endTrace({
-                name: PerpsTraceNames.CancelOrder,
-                id: traceId,
-            });
-        }
-    }
-    /**
-     * Close a single position with full orchestration.
-     * Handles tracing, fee discounts, state management, analytics, and data lake reporting.
-     *
-     * @param options - Options for closing position
-     * @param options.provider
-     * @param options.params
-     * @param options.context
-     * @param options.reportOrderToDataLake
-     * @returns Order result
-     */
-    async closePosition(options) {
-        const { provider, params, context, reportOrderToDataLake } = options;
-        const traceId = uuidv4();
-        const startTime = this.deps.performance.now();
-        let position;
-        let result;
-        let traceData;
-        try {
-            this.deps.tracer.trace({
-                name: PerpsTraceNames.ClosePosition,
-                id: traceId,
-                op: PerpsTraceOperations.PositionManagement,
-                tags: {
-                    provider: context.tracingContext.provider,
-                    symbol: params.symbol,
-                    closeSize: params.size || 'full',
-                    isTestnet: String(context.tracingContext.isTestnet),
-                },
-            });
-            // Load position data with measurement
-            position = await this.loadPositionData({
-                symbol: params.symbol,
-                context,
-            });
-            // Calculate fee discount with measurement
-            const feeDiscountBips = await this.calculateFeeDiscountWithMeasurement();
-            // Execute position close with fee discount management
-            result = await this.withFeeDiscount({
-                provider,
-                feeDiscountBips,
-                operation: () => provider.closePosition(params),
-            });
-            const completionDuration = this.deps.performance.now() - startTime;
-            if (result.success) {
-                // Update state on success
-                if (context.stateManager) {
-                    context.stateManager.update((state) => {
-                        state.lastUpdateTimestamp = Date.now();
-                    });
-                }
-                // Report to data lake (fire-and-forget)
-                this.handleDataLakeReporting(reportOrderToDataLake, params.symbol, context);
-                traceData = { success: true, filledSize: result.filledSize || '' };
-            }
-            else {
-                traceData = { success: false, error: result.error || 'Unknown error' };
-            }
-            // Track analytics (success or failure, includes partial fills)
-            this.trackPositionCloseResult({
-                position,
-                result,
-                params,
-                context,
-                duration: completionDuration,
-            });
-            return result;
-        }
-        catch (err) {
-            const completionDuration = this.deps.performance.now() - startTime;
-            const error = err instanceof Error ? err : new Error(String(err));
-            traceData = {
-                success: false,
-                error: error.message,
-            };
-            // Track analytics for exception
-            this.trackPositionCloseResult({
-                position,
-                result: null,
-                error,
-                params,
-                context,
-                duration: completionDuration,
-            });
-            this.deps.logger.error(error, {
-                tags: {
-                    feature: 'perps',
-                    provider: context.tracingContext.provider,
-                    network: context.tracingContext.isTestnet ? 'testnet' : 'mainnet',
-                },
-                context: {
-                    name: context.errorContext.controller,
-                    data: {
-                        method: context.errorContext.method,
-                        symbol: params.symbol,
-                    },
-                },
-            });
-            throw err;
-        }
-        finally {
-            // Always end trace on exit (success or failure)
-            this.deps.tracer.endTrace({
-                name: PerpsTraceNames.ClosePosition,
-                id: traceId,
-                data: traceData,
-            });
-        }
-    }
-    /**
-     * Close multiple positions with full orchestration.
-     * Handles tracing, fee discounts, batch operations, and analytics.
-     *
-     * @param options - Options for closing multiple positions
-     * @param options.provider
-     * @param options.params
-     * @param options.context
-     * @returns Close positions result
-     */
-    async closePositions(options) {
-        const { provider, params, context } = options;
-        const traceId = uuidv4();
-        const startTime = this.deps.performance.now();
-        let operationResult = null;
-        let operationError = null;
-        try {
-            // Start trace for batch operation
-            this.deps.tracer.trace({
-                name: PerpsTraceNames.ClosePosition,
-                id: traceId,
-                op: PerpsTraceOperations.PositionManagement,
-                tags: {
-                    provider: context.tracingContext.provider,
-                    isBatch: 'true',
-                    isTestnet: String(context.tracingContext.isTestnet),
-                },
-                data: {
-                    closeAll: params.closeAll ? 'true' : 'false',
-                    symbolCount: params.symbols?.length || 0,
-                },
-            });
-            this.deps.debugLogger.log('[closePositions] Batch method check', {
-                providerType: provider.protocolId,
-                hasBatchMethod: Boolean(provider.closePositions),
-                methodType: typeof provider.closePositions,
-                providerKeys: Object.keys(provider).filter((key) => key.includes('close')),
-            });
-            // Use batch close if provider supports it (provider handles filtering)
-            if (provider.closePositions) {
-                const feeDiscountBips = await this.calculateFeeDiscountWithMeasurement();
-                operationResult = await this.withFeeDiscount({
-                    provider,
-                    feeDiscountBips,
-                    operation: async () => {
-                        if (!provider.closePositions) {
-                            throw new Error('closePositions method not available');
-                        }
-                        return provider.closePositions(params);
-                    },
-                });
-            }
-            else {
-                // Fallback: Get positions, filter, and close in parallel
-                if (!context.getPositions) {
-                    throw new Error('getPositions callback not provided in context');
-                }
-                const positions = await context.getPositions();
-                const positionsToClose = params.closeAll || !params.symbols || params.symbols.length === 0
-                    ? positions
-                    : positions.filter((pos) => params.symbols?.includes(pos.symbol));
-                if (positionsToClose.length === 0) {
-                    operationResult = {
-                        success: false,
-                        successCount: 0,
-                        failureCount: 0,
-                        results: [],
-                    };
-                    return operationResult;
-                }
-                const results = await Promise.allSettled(positionsToClose.map((pos) => this.closePosition({
-                    provider,
-                    params: { symbol: pos.symbol },
-                    context,
-                    reportOrderToDataLake: () => Promise.resolve({ success: true }), // No-op for batch fallback
-                })));
-                // Aggregate results
-                const successCount = results.filter((resItem) => resItem.status === 'fulfilled' && resItem.value.success).length;
-                const failureCount = results.length - successCount;
-                operationResult = {
-                    success: successCount > 0,
-                    successCount,
-                    failureCount,
-                    results: results.map((resItem, index) => {
-                        let errorMsg;
-                        if (resItem.status === 'rejected') {
-                            errorMsg =
-                                resItem.reason instanceof Error
-                                    ? resItem.reason.message
-                                    : 'Unknown error';
-                        }
-                        else if (resItem.status === 'fulfilled' &&
-                            !resItem.value.success) {
-                            errorMsg = resItem.value.error;
-                        }
-                        return {
-                            symbol: positionsToClose[index].symbol,
-                            success: Boolean(resItem.status === 'fulfilled' && resItem.value.success),
-                            error: errorMsg,
-                        };
-                    }),
-                };
-            }
-            return operationResult;
-        }
-        catch (err) {
-            operationError = err instanceof Error ? err : new Error(String(err));
-            this.deps.logger.error(operationError, this.getErrorContext('closePositions', {
-                symbols: params.symbols?.length || 0,
-                closeAll: params.closeAll,
-            }));
-            throw err;
-        }
-        finally {
-            const completionDuration = this.deps.performance.now() - startTime;
-            // Track batch close event (success or failure)
-            const batchCloseProps = {
-                [PerpsEventProperties.STATUS]: operationResult?.success && operationResult.successCount > 0
-                    ? PerpsEventValues.STATUS.EXECUTED
-                    : PerpsEventValues.STATUS.FAILED,
-                [PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
-            };
-            if (operationError) {
-                batchCloseProps[PerpsEventProperties.ERROR_MESSAGE] =
-                    operationError.message;
-            }
-            this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.PositionCloseTransaction, batchCloseProps);
-            this.deps.tracer.endTrace({
-                name: PerpsTraceNames.ClosePosition,
-                id: traceId,
-            });
-        }
-    }
-    /**
-     * Update TP/SL for an existing position with full orchestration.
-     * Handles tracing, fee discounts, state management, and analytics.
-     *
-     * @param options - Options for updating TP/SL
-     * @param options.provider
-     * @param options.params
-     * @param options.context
-     * @returns Order result
-     */
-    async updatePositionTPSL(options) {
-        const { provider, params, context } = options;
-        const traceId = uuidv4();
-        const startTime = this.deps.performance.now();
-        let traceData;
-        let result;
-        let errorMessage;
-        // Extract tracking data with defaults
-        const direction = params.trackingData?.direction;
-        const positionSize = params.trackingData?.positionSize;
-        const source = params.trackingData?.source || PerpsEventValues.SOURCE.TP_SL_VIEW;
-        const takeProfitPercentage = params.trackingData?.takeProfitPercentage;
-        const stopLossPercentage = params.trackingData?.stopLossPercentage;
-        const isEditingExistingPosition = params.trackingData?.isEditingExistingPosition ?? false;
-        try {
-            this.deps.tracer.trace({
-                name: PerpsTraceNames.UpdateTpsl,
-                id: traceId,
-                op: PerpsTraceOperations.PositionManagement,
-                tags: {
-                    provider: context.tracingContext.provider,
-                    market: params.symbol,
-                    isTestnet: String(context.tracingContext.isTestnet),
-                },
-                data: {
-                    takeProfitPrice: params.takeProfitPrice || '',
-                    stopLossPrice: params.stopLossPrice || '',
-                },
-            });
-            // Get fee discount from rewards
-            const feeDiscountBips = await this.calculateFeeDiscountWithMeasurement();
-            // Execute with fee discount management
-            result = await this.withFeeDiscount({
-                provider,
-                feeDiscountBips,
-                operation: () => provider.updatePositionTPSL(params),
-            });
-            if (result.success) {
-                // Update state on success
-                if (context.stateManager) {
-                    context.stateManager.update((state) => {
-                        state.lastUpdateTimestamp = Date.now();
-                    });
-                }
-                traceData = { success: true };
-            }
-            else {
-                errorMessage = result.error || 'Unknown error';
-                traceData = { success: false, error: errorMessage };
-            }
-            return result;
-        }
-        catch (err) {
-            errorMessage = err instanceof Error ? err.message : 'Unknown error';
-            traceData = { success: false, error: errorMessage };
-            throw err;
-        }
-        finally {
-            const completionDuration = this.deps.performance.now() - startTime;
-            // Determine screen type based on whether editing existing position
-            const screenType = isEditingExistingPosition
-                ? PerpsEventValues.SCREEN_TYPE.EDIT_TPSL
-                : PerpsEventValues.SCREEN_TYPE.CREATE_TPSL;
-            // Determine if TP/SL are set
-            const hasTakeProfit = Boolean(params.takeProfitPrice);
-            const hasStopLoss = Boolean(params.stopLossPrice);
-            // Build comprehensive event properties
-            const eventProperties = {
-                [PerpsEventProperties.STATUS]: result?.success
-                    ? PerpsEventValues.STATUS.EXECUTED
-                    : PerpsEventValues.STATUS.FAILED,
-                [PerpsEventProperties.ASSET]: params.symbol,
-                [PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
-                [PerpsEventProperties.SOURCE]: source,
-                [PerpsEventProperties.SCREEN_TYPE]: screenType,
-                [PerpsEventProperties.HAS_TAKE_PROFIT]: hasTakeProfit,
-                [PerpsEventProperties.HAS_STOP_LOSS]: hasStopLoss,
-                ...(direction && {
-                    [PerpsEventProperties.DIRECTION]: direction === 'long'
-                        ? PerpsEventValues.DIRECTION.LONG
-                        : PerpsEventValues.DIRECTION.SHORT,
-                }),
-                ...(positionSize !== undefined && {
-                    [PerpsEventProperties.POSITION_SIZE]: positionSize,
-                }),
-                ...(params.takeProfitPrice && {
-                    [PerpsEventProperties.TAKE_PROFIT_PRICE]: parseFloat(params.takeProfitPrice),
-                }),
-                ...(params.stopLossPrice && {
-                    [PerpsEventProperties.STOP_LOSS_PRICE]: parseFloat(params.stopLossPrice),
-                }),
-                ...(takeProfitPercentage !== undefined && {
-                    [PerpsEventProperties.TAKE_PROFIT_PERCENTAGE]: takeProfitPercentage,
-                }),
-                ...(stopLossPercentage !== undefined && {
-                    [PerpsEventProperties.STOP_LOSS_PERCENTAGE]: stopLossPercentage,
-                }),
-                ...(errorMessage && {
-                    [PerpsEventProperties.ERROR_MESSAGE]: errorMessage,
-                }),
-            };
-            // Track event once with all properties
-            this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.RiskManagement, eventProperties);
-            this.deps.tracer.endTrace({
-                name: PerpsTraceNames.UpdateTpsl,
-                id: traceId,
-                data: traceData,
-            });
-        }
-    }
-    /**
-     * Update margin for an existing position (add or remove).
-     *
-     * @param options - Options for updating margin
-     * @param options.provider
-     * @param options.symbol
-     * @param options.amount
-     * @param options.context
-     * @returns Margin update result
-     */
-    async updateMargin(options) {
-        const { provider, symbol, amount, context } = options;
-        const traceId = uuidv4();
-        const startTime = this.deps.performance.now();
-        try {
-            this.deps.tracer.trace({
-                name: PerpsTraceNames.UpdateMargin,
-                id: traceId,
-                op: PerpsTraceOperations.PositionManagement,
-                tags: {
-                    provider: context.tracingContext.provider,
-                    symbol,
-                    isAdd: String(parseFloat(amount) > 0),
-                    isTestnet: String(context.tracingContext.isTestnet),
-                },
-            });
-            // Call provider method
-            const result = await provider.updateMargin?.({ symbol, amount });
-            if (!result) {
-                throw new Error('Provider does not support margin adjustment');
-            }
-            const completionDuration = this.deps.performance.now() - startTime;
-            if (result.success) {
-                // Update state on success
-                if (context.stateManager) {
-                    context.stateManager.update((state) => {
-                        state.lastUpdateTimestamp = Date.now();
-                    });
-                }
-                // Track success analytics
-                this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.RiskManagement, {
-                    [PerpsEventProperties.STATUS]: PerpsEventValues.STATUS.EXECUTED,
-                    [PerpsEventProperties.ASSET]: symbol,
-                    [PerpsEventProperties.ACTION]: parseFloat(amount) > 0 ? 'add_margin' : 'remove_margin',
-                    [PerpsEventProperties.MARGIN_USED]: Math.abs(parseFloat(amount)),
-                    [PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
-                });
-            }
-            this.deps.tracer.endTrace({
-                name: PerpsTraceNames.UpdateMargin,
-                id: traceId,
-                data: { success: result.success, error: result.error || '' },
-            });
-            return result;
-        }
-        catch (err) {
-            const completionDuration = this.deps.performance.now() - startTime;
-            const errorMessage = err instanceof Error ? err.message : 'Unknown error';
-            const error = err instanceof Error ? err : new Error(String(err));
-            this.deps.logger.error(error, this.getErrorContext('updateMargin', { symbol, amount }));
-            // Track failure analytics
-            this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.RiskManagement, {
-                [PerpsEventProperties.STATUS]: PerpsEventValues.STATUS.FAILED,
-                [PerpsEventProperties.ASSET]: symbol,
-                [PerpsEventProperties.ACTION]: parseFloat(amount) > 0 ? 'add_margin' : 'remove_margin',
-                [PerpsEventProperties.MARGIN_USED]: Math.abs(parseFloat(amount)),
-                [PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
-                [PerpsEventProperties.ERROR_MESSAGE]: errorMessage,
-            });
-            this.deps.tracer.endTrace({
-                name: PerpsTraceNames.UpdateMargin,
-                id: traceId,
-                data: { success: false, error: errorMessage },
-            });
-            throw err;
-        }
-    }
-    /**
-     * Flip position (reverse direction while keeping size and leverage).
-     *
-     * @param options - Options for flipping position
-     * @param options.provider
-     * @param options.position
-     * @param options.context
-     * @returns Order result
-     */
-    async flipPosition(options) {
-        const { provider, position, context } = options;
-        const traceId = uuidv4();
-        const startTime = this.deps.performance.now();
-        try {
-            this.deps.tracer.trace({
-                name: PerpsTraceNames.FlipPosition,
-                id: traceId,
-                op: PerpsTraceOperations.PositionManagement,
-                tags: {
-                    provider: context.tracingContext.provider,
-                    symbol: position.symbol,
-                    isTestnet: String(context.tracingContext.isTestnet),
-                },
-            });
-            // Calculate flip parameters
-            const positionSize = Math.abs(parseFloat(position.size));
-            const isCurrentlyLong = parseFloat(position.size) > 0;
-            const oppositeDirection = !isCurrentlyLong;
-            // Validate available balance for fees
-            const accountState = await provider.getAccountState?.();
-            if (!accountState) {
-                throw new Error('Failed to get account state');
-            }
-            const availableBalance = parseFloat(accountState.availableBalance);
-            // Estimate fees (close + open, approximately 0.09% of notional)
-            // Flip requires 2x position size (1x to close, 1x to open opposite)
-            const entryPrice = parseFloat(position.entryPrice);
-            const flipSize = positionSize * 2;
-            const notionalValue = flipSize * entryPrice;
-            const estimatedFees = notionalValue * 0.0009;
-            if (estimatedFees > availableBalance) {
-                throw new Error(`Insufficient balance for flip fees. Need $${estimatedFees.toFixed(2)}, have $${availableBalance.toFixed(2)}`);
-            }
-            // Create order params for flip
-            // Use 2x position size: 1x to close current position + 1x to open opposite position
-            const orderParams = {
-                symbol: position.symbol,
-                isBuy: oppositeDirection,
-                size: flipSize.toString(),
-                orderType: 'market',
-                leverage: position.leverage?.value,
-                currentPrice: entryPrice,
-            };
-            // Place flip order (HyperLiquid handles margin transfer automatically)
-            const result = await provider.placeOrder(orderParams);
-            const completionDuration = this.deps.performance.now() - startTime;
-            if (result.success) {
-                // Update state on success
-                if (context.stateManager) {
-                    context.stateManager.update((state) => {
-                        state.lastUpdateTimestamp = Date.now();
-                    });
-                }
-                // Track success analytics
-                this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.TradeTransaction, {
-                    [PerpsEventProperties.STATUS]: PerpsEventValues.STATUS.EXECUTED,
-                    [PerpsEventProperties.ASSET]: position.symbol,
-                    [PerpsEventProperties.DIRECTION]: oppositeDirection
-                        ? PerpsEventValues.DIRECTION.LONG
-                        : PerpsEventValues.DIRECTION.SHORT,
-                    [PerpsEventProperties.ORDER_TYPE]: 'market',
-                    [PerpsEventProperties.LEVERAGE]: position.leverage?.value || 1,
-                    [PerpsEventProperties.ORDER_SIZE]: positionSize,
-                    [PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
-                    [PerpsEventProperties.ACTION]: 'flip_position',
-                });
-            }
-            this.deps.tracer.endTrace({
-                name: PerpsTraceNames.FlipPosition,
-                id: traceId,
-                data: { success: result.success ?? false, error: result.error || '' },
-            });
-            return result;
-        }
-        catch (err) {
-            const completionDuration = this.deps.performance.now() - startTime;
-            const errorMessage = err instanceof Error ? err.message : 'Unknown error';
-            const error = err instanceof Error ? err : new Error(String(err));
-            this.deps.logger.error(error, this.getErrorContext('flipPosition', { symbol: position.symbol }));
-            // Track failure analytics
-            this.deps.metrics.trackPerpsEvent(PerpsAnalyticsEvent.TradeTransaction, {
-                [PerpsEventProperties.STATUS]: PerpsEventValues.STATUS.FAILED,
-                [PerpsEventProperties.ASSET]: position.symbol,
-                [PerpsEventProperties.ACTION]: 'flip_position',
-                [PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
-                [PerpsEventProperties.ERROR_MESSAGE]: errorMessage,
-            });
-            this.deps.tracer.endTrace({
-                name: PerpsTraceNames.FlipPosition,
-                id: traceId,
-                data: { success: false, error: errorMessage },
-            });
-            throw err;
-        }
-    }
-}
-//# sourceMappingURL=TradingService.mjs.map