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

package/dist/services/TradingService.cjs

@@ -0,0 +1,1481 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradingService = void 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
+const uuid_1 = require("uuid");
+const eventNames_1 = require("../constants/eventNames.cjs");
+const orderTypes_1 = require("../constants/orderTypes.cjs");
+const performanceMetrics_1 = require("../constants/performanceMetrics.cjs");
+const types_1 = require("../types/index.cjs");
+/**
+ * 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.
+ */
+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
+            ? eventNames_1.PerpsEventValues.STATUS.EXECUTED
+            : eventNames_1.PerpsEventValues.STATUS.FAILED;
+        // Build base properties
+        const properties = {
+            [eventNames_1.PerpsEventProperties.STATUS]: status,
+            [eventNames_1.PerpsEventProperties.ASSET]: params.symbol,
+            [eventNames_1.PerpsEventProperties.DIRECTION]: params.isBuy
+                ? eventNames_1.PerpsEventValues.DIRECTION.LONG
+                : eventNames_1.PerpsEventValues.DIRECTION.SHORT,
+            [eventNames_1.PerpsEventProperties.ORDER_TYPE]: params.orderType,
+            [eventNames_1.PerpsEventProperties.LEVERAGE]: parseFloat(String(params.leverage || 1)),
+            [eventNames_1.PerpsEventProperties.ORDER_SIZE]: parseFloat(result?.filledSize || params.size),
+            [eventNames_1.PerpsEventProperties.COMPLETION_DURATION]: duration,
+        };
+        // Add optional properties
+        if (params.trackingData?.marginUsed != null) {
+            properties[eventNames_1.PerpsEventProperties.MARGIN_USED] =
+                params.trackingData.marginUsed;
+        }
+        if (params.trackingData?.totalFee != null) {
+            properties[eventNames_1.PerpsEventProperties.FEES] = params.trackingData.totalFee;
+        }
+        if (result?.averagePrice || params.trackingData?.marketPrice) {
+            properties[eventNames_1.PerpsEventProperties.ASSET_PRICE] = result?.averagePrice
+                ? parseFloat(result.averagePrice)
+                : params.trackingData?.marketPrice;
+        }
+        if (params.orderType === 'limit' && params.price) {
+            properties[eventNames_1.PerpsEventProperties.LIMIT_PRICE] = parseFloat(params.price);
+        }
+        if (params.trackingData?.source) {
+            properties[eventNames_1.PerpsEventProperties.SOURCE] = params.trackingData.source;
+        }
+        if (params.trackingData?.tradeAction) {
+            properties[eventNames_1.PerpsEventProperties.ACTION] = params.trackingData.tradeAction;
+        }
+        // Add success-specific properties
+        if (status === eventNames_1.PerpsEventValues.STATUS.EXECUTED) {
+            if (params.trackingData?.metamaskFee != null) {
+                properties[eventNames_1.PerpsEventProperties.METAMASK_FEE] =
+                    params.trackingData.metamaskFee;
+            }
+            if (params.trackingData?.metamaskFeeRate != null) {
+                properties[eventNames_1.PerpsEventProperties.METAMASK_FEE_RATE] =
+                    params.trackingData.metamaskFeeRate;
+            }
+            if (params.trackingData?.feeDiscountPercentage != null) {
+                properties[eventNames_1.PerpsEventProperties.DISCOUNT_PERCENTAGE] =
+                    params.trackingData.feeDiscountPercentage;
+            }
+            if (params.trackingData?.estimatedPoints != null) {
+                properties[eventNames_1.PerpsEventProperties.ESTIMATED_REWARDS] =
+                    params.trackingData.estimatedPoints;
+            }
+            if (params.takeProfitPrice) {
+                properties[eventNames_1.PerpsEventProperties.TAKE_PROFIT_PRICE] = parseFloat(params.takeProfitPrice);
+            }
+            if (params.stopLossPrice) {
+                properties[eventNames_1.PerpsEventProperties.STOP_LOSS_PRICE] = parseFloat(params.stopLossPrice);
+            }
+        }
+        else {
+            // Add failure-specific properties
+            properties[eventNames_1.PerpsEventProperties.ERROR_MESSAGE] =
+                error?.message || result?.error || 'Unknown error';
+        }
+        this.deps.metrics.trackPerpsEvent(types_1.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 = (0, uuid_1.v4)();
+        const startTime = this.deps.performance.now();
+        let traceData;
+        try {
+            // Start trace for the entire operation
+            this.deps.tracer.trace({
+                name: types_1.PerpsTraceNames.PlaceOrder,
+                id: traceId,
+                op: types_1.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: types_1.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(performanceMetrics_1.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
+            ? eventNames_1.PerpsEventValues.DIRECTION.LONG
+            : eventNames_1.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 || eventNames_1.PerpsEventValues.ORDER_TYPE.MARKET;
+        const closePercentage = params.size
+            ? (parseFloat(params.size) / Math.abs(parseFloat(position.size))) * 100
+            : 100;
+        const closeType = closePercentage === 100
+            ? eventNames_1.PerpsEventValues.CLOSE_TYPE.FULL
+            : eventNames_1.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 = {
+            [eventNames_1.PerpsEventProperties.STATUS]: status,
+            [eventNames_1.PerpsEventProperties.ASSET]: position.symbol,
+            [eventNames_1.PerpsEventProperties.DIRECTION]: metrics.direction,
+            [eventNames_1.PerpsEventProperties.ORDER_TYPE]: metrics.orderType,
+            [eventNames_1.PerpsEventProperties.ORDER_SIZE]: metrics.requestedSize,
+            [eventNames_1.PerpsEventProperties.OPEN_POSITION_SIZE]: Math.abs(parseFloat(position.size)),
+            [eventNames_1.PerpsEventProperties.PERCENTAGE_CLOSED]: metrics.closePercentage,
+            ...(position.unrealizedPnl && {
+                [eventNames_1.PerpsEventProperties.PNL_DOLLAR]: parseFloat(position.unrealizedPnl),
+            }),
+            ...(position.returnOnEquity && {
+                [eventNames_1.PerpsEventProperties.PNL_PERCENT]: parseFloat(position.returnOnEquity) * 100,
+            }),
+            ...(params.trackingData?.totalFee != null && {
+                [eventNames_1.PerpsEventProperties.FEE]: params.trackingData.totalFee,
+            }),
+            ...(params.trackingData?.metamaskFee != null && {
+                [eventNames_1.PerpsEventProperties.METAMASK_FEE]: params.trackingData.metamaskFee,
+            }),
+            ...(params.trackingData?.metamaskFeeRate != null && {
+                [eventNames_1.PerpsEventProperties.METAMASK_FEE_RATE]: params.trackingData.metamaskFeeRate,
+            }),
+            ...(params.trackingData?.feeDiscountPercentage != null && {
+                [eventNames_1.PerpsEventProperties.DISCOUNT_PERCENTAGE]: params.trackingData.feeDiscountPercentage,
+            }),
+            ...(params.trackingData?.estimatedPoints != null && {
+                [eventNames_1.PerpsEventProperties.ESTIMATED_REWARDS]: params.trackingData.estimatedPoints,
+            }),
+            ...((params.trackingData?.marketPrice || result?.averagePrice) && {
+                [eventNames_1.PerpsEventProperties.ASSET_PRICE]: result?.averagePrice
+                    ? parseFloat(result.averagePrice)
+                    : params.trackingData?.marketPrice,
+            }),
+            ...(params.orderType === 'limit' &&
+                params.price && {
+                [eventNames_1.PerpsEventProperties.LIMIT_PRICE]: parseFloat(params.price),
+            }),
+            ...(params.trackingData?.receivedAmount != null && {
+                [eventNames_1.PerpsEventProperties.RECEIVED_AMOUNT]: params.trackingData.receivedAmount,
+            }),
+        };
+        // Add success-specific properties
+        if (status === eventNames_1.PerpsEventValues.STATUS.EXECUTED) {
+            return {
+                ...baseProperties,
+                [eventNames_1.PerpsEventProperties.CLOSE_TYPE]: metrics.closeType,
+            };
+        }
+        // Add error for failures
+        return {
+            ...baseProperties,
+            ...(error && { [eventNames_1.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
+                    ? eventNames_1.PerpsEventValues.DIRECTION.LONG
+                    : eventNames_1.PerpsEventValues.DIRECTION.SHORT,
+                closePercentage: params.size
+                    ? (parseFloat(params.size) / Math.abs(parseFloat(position.size))) *
+                        100
+                    : 100,
+                closeType: eventNames_1.PerpsEventValues.CLOSE_TYPE.FULL,
+                orderType: params.orderType || eventNames_1.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, eventNames_1.PerpsEventValues.STATUS.PARTIALLY_FILLED);
+            this.deps.metrics.trackPerpsEvent(types_1.PerpsAnalyticsEvent.PositionCloseTransaction, {
+                ...partialProperties,
+                [eventNames_1.PerpsEventProperties.AMOUNT_FILLED]: metrics.filledSize,
+                [eventNames_1.PerpsEventProperties.REMAINING_AMOUNT]: metrics.requestedSize - metrics.filledSize,
+                [eventNames_1.PerpsEventProperties.COMPLETION_DURATION]: duration,
+            });
+        }
+        // Determine status
+        const status = result?.success === true
+            ? eventNames_1.PerpsEventValues.STATUS.EXECUTED
+            : eventNames_1.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(types_1.PerpsAnalyticsEvent.PositionCloseTransaction, {
+            ...eventProperties,
+            [eventNames_1.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(performanceMetrics_1.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 = (0, uuid_1.v4)();
+        const startTime = this.deps.performance.now();
+        let traceData;
+        try {
+            this.deps.tracer.trace({
+                name: types_1.PerpsTraceNames.EditOrder,
+                id: traceId,
+                op: types_1.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 = {
+                    [eventNames_1.PerpsEventProperties.STATUS]: eventNames_1.PerpsEventValues.STATUS.EXECUTED,
+                    [eventNames_1.PerpsEventProperties.ASSET]: params.newOrder.symbol,
+                    [eventNames_1.PerpsEventProperties.DIRECTION]: params.newOrder.isBuy
+                        ? eventNames_1.PerpsEventValues.DIRECTION.LONG
+                        : eventNames_1.PerpsEventValues.DIRECTION.SHORT,
+                    [eventNames_1.PerpsEventProperties.ORDER_TYPE]: params.newOrder.orderType,
+                    [eventNames_1.PerpsEventProperties.LEVERAGE]: params.newOrder.leverage || 1,
+                    [eventNames_1.PerpsEventProperties.ORDER_SIZE]: params.newOrder.size,
+                    [eventNames_1.PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
+                };
+                if (params.newOrder.price) {
+                    editExecutedProps[eventNames_1.PerpsEventProperties.LIMIT_PRICE] = parseFloat(params.newOrder.price);
+                }
+                this.deps.metrics.trackPerpsEvent(types_1.PerpsAnalyticsEvent.TradeTransaction, editExecutedProps);
+                traceData = { success: true, orderId: result.orderId || '' };
+            }
+            else {
+                // Track order edit failed
+                this.deps.metrics.trackPerpsEvent(types_1.PerpsAnalyticsEvent.TradeTransaction, {
+                    [eventNames_1.PerpsEventProperties.STATUS]: eventNames_1.PerpsEventValues.STATUS.FAILED,
+                    [eventNames_1.PerpsEventProperties.ASSET]: params.newOrder.symbol,
+                    [eventNames_1.PerpsEventProperties.DIRECTION]: params.newOrder.isBuy
+                        ? eventNames_1.PerpsEventValues.DIRECTION.LONG
+                        : eventNames_1.PerpsEventValues.DIRECTION.SHORT,
+                    [eventNames_1.PerpsEventProperties.ORDER_TYPE]: params.newOrder.orderType,
+                    [eventNames_1.PerpsEventProperties.LEVERAGE]: params.newOrder.leverage || 1,
+                    [eventNames_1.PerpsEventProperties.ORDER_SIZE]: params.newOrder.size,
+                    [eventNames_1.PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
+                    [eventNames_1.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(types_1.PerpsAnalyticsEvent.TradeTransaction, {
+                [eventNames_1.PerpsEventProperties.STATUS]: eventNames_1.PerpsEventValues.STATUS.FAILED,
+                [eventNames_1.PerpsEventProperties.ASSET]: params.newOrder.symbol,
+                [eventNames_1.PerpsEventProperties.DIRECTION]: params.newOrder.isBuy
+                    ? eventNames_1.PerpsEventValues.DIRECTION.LONG
+                    : eventNames_1.PerpsEventValues.DIRECTION.SHORT,
+                [eventNames_1.PerpsEventProperties.ORDER_TYPE]: params.newOrder.orderType,
+                [eventNames_1.PerpsEventProperties.LEVERAGE]: params.newOrder.leverage || 1,
+                [eventNames_1.PerpsEventProperties.ORDER_SIZE]: params.newOrder.size,
+                [eventNames_1.PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
+                [eventNames_1.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: types_1.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 = (0, uuid_1.v4)();
+        const startTime = this.deps.performance.now();
+        let traceData;
+        try {
+            // Start trace for the entire operation
+            this.deps.tracer.trace({
+                name: types_1.PerpsTraceNames.CancelOrder,
+                id: traceId,
+                op: types_1.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(types_1.PerpsAnalyticsEvent.OrderCancelTransaction, {
+                    [eventNames_1.PerpsEventProperties.STATUS]: eventNames_1.PerpsEventValues.STATUS.EXECUTED,
+                    [eventNames_1.PerpsEventProperties.ASSET]: params.symbol,
+                    [eventNames_1.PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
+                });
+                traceData = { success: true, orderId: params.orderId };
+            }
+            else {
+                // Track order cancel failed
+                this.deps.metrics.trackPerpsEvent(types_1.PerpsAnalyticsEvent.OrderCancelTransaction, {
+                    [eventNames_1.PerpsEventProperties.STATUS]: eventNames_1.PerpsEventValues.STATUS.FAILED,
+                    [eventNames_1.PerpsEventProperties.ASSET]: params.symbol,
+                    [eventNames_1.PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
+                    [eventNames_1.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(types_1.PerpsAnalyticsEvent.OrderCancelTransaction, {
+                [eventNames_1.PerpsEventProperties.STATUS]: eventNames_1.PerpsEventValues.STATUS.FAILED,
+                [eventNames_1.PerpsEventProperties.ASSET]: params.symbol,
+                [eventNames_1.PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
+                [eventNames_1.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: types_1.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 = (0, uuid_1.v4)();
+        const startTime = this.deps.performance.now();
+        let operationResult = null;
+        let operationError = null;
+        try {
+            // Start trace for batch operation
+            this.deps.tracer.trace({
+                name: types_1.PerpsTraceNames.CancelOrder,
+                id: traceId,
+                op: types_1.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) => !(0, orderTypes_1.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 = {
+                [eventNames_1.PerpsEventProperties.STATUS]: operationResult?.success && operationResult.successCount > 0
+                    ? eventNames_1.PerpsEventValues.STATUS.EXECUTED
+                    : eventNames_1.PerpsEventValues.STATUS.FAILED,
+                [eventNames_1.PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
+            };
+            if (operationError) {
+                batchCancelProps[eventNames_1.PerpsEventProperties.ERROR_MESSAGE] =
+                    operationError.message;
+            }
+            this.deps.metrics.trackPerpsEvent(types_1.PerpsAnalyticsEvent.OrderCancelTransaction, batchCancelProps);
+            this.deps.tracer.endTrace({
+                name: types_1.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 = (0, uuid_1.v4)();
+        const startTime = this.deps.performance.now();
+        let position;
+        let result;
+        let traceData;
+        try {
+            this.deps.tracer.trace({
+                name: types_1.PerpsTraceNames.ClosePosition,
+                id: traceId,
+                op: types_1.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: types_1.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 = (0, uuid_1.v4)();
+        const startTime = this.deps.performance.now();
+        let operationResult = null;
+        let operationError = null;
+        try {
+            // Start trace for batch operation
+            this.deps.tracer.trace({
+                name: types_1.PerpsTraceNames.ClosePosition,
+                id: traceId,
+                op: types_1.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 = {
+                [eventNames_1.PerpsEventProperties.STATUS]: operationResult?.success && operationResult.successCount > 0
+                    ? eventNames_1.PerpsEventValues.STATUS.EXECUTED
+                    : eventNames_1.PerpsEventValues.STATUS.FAILED,
+                [eventNames_1.PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
+            };
+            if (operationError) {
+                batchCloseProps[eventNames_1.PerpsEventProperties.ERROR_MESSAGE] =
+                    operationError.message;
+            }
+            this.deps.metrics.trackPerpsEvent(types_1.PerpsAnalyticsEvent.PositionCloseTransaction, batchCloseProps);
+            this.deps.tracer.endTrace({
+                name: types_1.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 = (0, uuid_1.v4)();
+        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 || eventNames_1.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: types_1.PerpsTraceNames.UpdateTpsl,
+                id: traceId,
+                op: types_1.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
+                ? eventNames_1.PerpsEventValues.SCREEN_TYPE.EDIT_TPSL
+                : eventNames_1.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 = {
+                [eventNames_1.PerpsEventProperties.STATUS]: result?.success
+                    ? eventNames_1.PerpsEventValues.STATUS.EXECUTED
+                    : eventNames_1.PerpsEventValues.STATUS.FAILED,
+                [eventNames_1.PerpsEventProperties.ASSET]: params.symbol,
+                [eventNames_1.PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
+                [eventNames_1.PerpsEventProperties.SOURCE]: source,
+                [eventNames_1.PerpsEventProperties.SCREEN_TYPE]: screenType,
+                [eventNames_1.PerpsEventProperties.HAS_TAKE_PROFIT]: hasTakeProfit,
+                [eventNames_1.PerpsEventProperties.HAS_STOP_LOSS]: hasStopLoss,
+                ...(direction && {
+                    [eventNames_1.PerpsEventProperties.DIRECTION]: direction === 'long'
+                        ? eventNames_1.PerpsEventValues.DIRECTION.LONG
+                        : eventNames_1.PerpsEventValues.DIRECTION.SHORT,
+                }),
+                ...(positionSize !== undefined && {
+                    [eventNames_1.PerpsEventProperties.POSITION_SIZE]: positionSize,
+                }),
+                ...(params.takeProfitPrice && {
+                    [eventNames_1.PerpsEventProperties.TAKE_PROFIT_PRICE]: parseFloat(params.takeProfitPrice),
+                }),
+                ...(params.stopLossPrice && {
+                    [eventNames_1.PerpsEventProperties.STOP_LOSS_PRICE]: parseFloat(params.stopLossPrice),
+                }),
+                ...(takeProfitPercentage !== undefined && {
+                    [eventNames_1.PerpsEventProperties.TAKE_PROFIT_PERCENTAGE]: takeProfitPercentage,
+                }),
+                ...(stopLossPercentage !== undefined && {
+                    [eventNames_1.PerpsEventProperties.STOP_LOSS_PERCENTAGE]: stopLossPercentage,
+                }),
+                ...(errorMessage && {
+                    [eventNames_1.PerpsEventProperties.ERROR_MESSAGE]: errorMessage,
+                }),
+            };
+            // Track event once with all properties
+            this.deps.metrics.trackPerpsEvent(types_1.PerpsAnalyticsEvent.RiskManagement, eventProperties);
+            this.deps.tracer.endTrace({
+                name: types_1.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 = (0, uuid_1.v4)();
+        const startTime = this.deps.performance.now();
+        try {
+            this.deps.tracer.trace({
+                name: types_1.PerpsTraceNames.UpdateMargin,
+                id: traceId,
+                op: types_1.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(types_1.PerpsAnalyticsEvent.RiskManagement, {
+                    [eventNames_1.PerpsEventProperties.STATUS]: eventNames_1.PerpsEventValues.STATUS.EXECUTED,
+                    [eventNames_1.PerpsEventProperties.ASSET]: symbol,
+                    [eventNames_1.PerpsEventProperties.ACTION]: parseFloat(amount) > 0 ? 'add_margin' : 'remove_margin',
+                    [eventNames_1.PerpsEventProperties.MARGIN_USED]: Math.abs(parseFloat(amount)),
+                    [eventNames_1.PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
+                });
+            }
+            this.deps.tracer.endTrace({
+                name: types_1.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(types_1.PerpsAnalyticsEvent.RiskManagement, {
+                [eventNames_1.PerpsEventProperties.STATUS]: eventNames_1.PerpsEventValues.STATUS.FAILED,
+                [eventNames_1.PerpsEventProperties.ASSET]: symbol,
+                [eventNames_1.PerpsEventProperties.ACTION]: parseFloat(amount) > 0 ? 'add_margin' : 'remove_margin',
+                [eventNames_1.PerpsEventProperties.MARGIN_USED]: Math.abs(parseFloat(amount)),
+                [eventNames_1.PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
+                [eventNames_1.PerpsEventProperties.ERROR_MESSAGE]: errorMessage,
+            });
+            this.deps.tracer.endTrace({
+                name: types_1.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 = (0, uuid_1.v4)();
+        const startTime = this.deps.performance.now();
+        try {
+            this.deps.tracer.trace({
+                name: types_1.PerpsTraceNames.FlipPosition,
+                id: traceId,
+                op: types_1.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(types_1.PerpsAnalyticsEvent.TradeTransaction, {
+                    [eventNames_1.PerpsEventProperties.STATUS]: eventNames_1.PerpsEventValues.STATUS.EXECUTED,
+                    [eventNames_1.PerpsEventProperties.ASSET]: position.symbol,
+                    [eventNames_1.PerpsEventProperties.DIRECTION]: oppositeDirection
+                        ? eventNames_1.PerpsEventValues.DIRECTION.LONG
+                        : eventNames_1.PerpsEventValues.DIRECTION.SHORT,
+                    [eventNames_1.PerpsEventProperties.ORDER_TYPE]: 'market',
+                    [eventNames_1.PerpsEventProperties.LEVERAGE]: position.leverage?.value || 1,
+                    [eventNames_1.PerpsEventProperties.ORDER_SIZE]: positionSize,
+                    [eventNames_1.PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
+                    [eventNames_1.PerpsEventProperties.ACTION]: 'flip_position',
+                });
+            }
+            this.deps.tracer.endTrace({
+                name: types_1.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(types_1.PerpsAnalyticsEvent.TradeTransaction, {
+                [eventNames_1.PerpsEventProperties.STATUS]: eventNames_1.PerpsEventValues.STATUS.FAILED,
+                [eventNames_1.PerpsEventProperties.ASSET]: position.symbol,
+                [eventNames_1.PerpsEventProperties.ACTION]: 'flip_position',
+                [eventNames_1.PerpsEventProperties.COMPLETION_DURATION]: completionDuration,
+                [eventNames_1.PerpsEventProperties.ERROR_MESSAGE]: errorMessage,
+            });
+            this.deps.tracer.endTrace({
+                name: types_1.PerpsTraceNames.FlipPosition,
+                id: traceId,
+                data: { success: false, error: errorMessage },
+            });
+            throw err;
+        }
+    }
+}
+exports.TradingService = TradingService;
+//# sourceMappingURL=TradingService.cjs.map