clodds 1.1.0

package/dist/trading/futures/index.js

@@ -0,0 +1,4011 @@
+"use strict";
+/**
+ * Futures Trading Module
+ *
+ * Real perpetual futures trading with leverage across multiple exchanges:
+ * - Binance Futures (USDT-M perpetuals)
+ * - Bybit (USDT perpetuals)
+ * - Hyperliquid (decentralized, on Arbitrum)
+ *
+ * Features:
+ * - Custom strategy support with variable tracking
+ * - Database persistence for trade history & A/B testing
+ * - Strategy variants for performance comparison
+ * - Easy setup with config or environment variables
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MexcFuturesClient = exports.HyperliquidClient = exports.BybitFuturesClient = exports.BinanceFuturesClient = exports.GridStrategy = exports.MeanReversionStrategy = exports.MomentumStrategy = exports.FuturesService = exports.StrategyEngine = exports.FuturesDatabase = void 0;
+exports.createFuturesService = createFuturesService;
+exports.setupFromEnv = setupFromEnv;
+const events_1 = require("events");
+const crypto_1 = require("crypto");
+const secp = __importStar(require("@noble/secp256k1"));
+const sha3_1 = require("@noble/hashes/sha3");
+const logger_1 = require("../../utils/logger");
+const pg_1 = require("pg");
+// =============================================================================
+// HELPERS
+// =============================================================================
+/** Safe parseFloat that returns fallback instead of NaN */
+function safeFloat(value, fallback = 0) {
+    const n = parseFloat(String(value));
+    return isNaN(n) || !isFinite(n) ? fallback : n;
+}
+/** Fetch with retry for transient errors (429, 502, 503, 504) */
+async function fetchWithRetry(url, init, maxRetries = 3) {
+    const retryableStatuses = new Set([429, 502, 503, 504]);
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            const response = await fetch(url, init);
+            if (retryableStatuses.has(response.status) && attempt < maxRetries) {
+                const delay = Math.min(1000 * 2 ** attempt, 10_000);
+                await new Promise(r => setTimeout(r, delay));
+                continue;
+            }
+            return response;
+        }
+        catch (err) {
+            lastError = err;
+            // Retry on network errors, not on abort (timeout)
+            if (err.name === 'AbortError')
+                throw err;
+            if (attempt < maxRetries) {
+                const delay = Math.min(1000 * 2 ** attempt, 10_000);
+                await new Promise(r => setTimeout(r, delay));
+                continue;
+            }
+        }
+    }
+    throw lastError || new Error('Fetch failed after retries');
+}
+// =============================================================================
+// CRYPTO UTILITIES (using @noble/secp256k1 - no elliptic dependency)
+// =============================================================================
+function keccak256(data) {
+    return Buffer.from((0, sha3_1.keccak_256)(data));
+}
+function signMessage(message, privateKey) {
+    const privKeyBytes = Buffer.from(privateKey.replace('0x', ''), 'hex');
+    const msgHash = keccak256(message);
+    // Use 'recovered' format to get signature with recovery bit (65 bytes: r + s + v)
+    const sigBytes = secp.sign(msgHash, privKeyBytes, { format: 'recovered', prehash: false });
+    return {
+        r: '0x' + Buffer.from(sigBytes.slice(0, 32)).toString('hex'),
+        s: '0x' + Buffer.from(sigBytes.slice(32, 64)).toString('hex'),
+        v: sigBytes[64] + 27,
+    };
+}
+// =============================================================================
+// BINANCE FUTURES CLIENT
+// =============================================================================
+class BinanceFuturesClient {
+    apiKey;
+    apiSecret;
+    baseUrl;
+    dryRun;
+    constructor(credentials, dryRun = false) {
+        this.apiKey = credentials.apiKey;
+        this.apiSecret = credentials.apiSecret;
+        this.baseUrl = credentials.testnet
+            ? 'https://testnet.binancefuture.com'
+            : 'https://fapi.binance.com';
+        this.dryRun = dryRun;
+    }
+    sign(params) {
+        const queryString = Object.entries(params)
+            .map(([k, v]) => `${k}=${v}`)
+            .join('&');
+        return (0, crypto_1.createHmac)('sha256', this.apiSecret).update(queryString).digest('hex');
+    }
+    async request(method, endpoint, params = {}, signed = false) {
+        const url = new URL(endpoint, this.baseUrl);
+        if (signed) {
+            params.timestamp = Date.now();
+            params.signature = this.sign(params);
+        }
+        if (method === 'GET') {
+            Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, String(v)));
+        }
+        const response = await fetchWithRetry(url.toString(), {
+            method,
+            headers: {
+                'X-MBX-APIKEY': this.apiKey,
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            body: method !== 'GET' ? new URLSearchParams(params).toString() : undefined,
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ msg: response.statusText }));
+            throw new Error(`Binance error: ${error.msg || response.statusText}`);
+        }
+        return response.json();
+    }
+    async getBalance() {
+        const data = await this.request('GET', '/fapi/v2/balance', {}, true);
+        const usdt = data.find(b => b.asset === 'USDT') || { availableBalance: '0', balance: '0', crossUnPnl: '0' };
+        return {
+            exchange: 'binance',
+            asset: 'USDT',
+            available: safeFloat(usdt.availableBalance),
+            total: safeFloat(usdt.balance),
+            unrealizedPnl: safeFloat(usdt.crossUnPnl),
+            marginBalance: safeFloat(usdt.balance) + safeFloat(usdt.crossUnPnl),
+        };
+    }
+    async getPositions() {
+        const data = await this.request('GET', '/fapi/v2/positionRisk', {}, true);
+        return data
+            .filter(p => safeFloat(p.positionAmt) !== 0)
+            .map(p => {
+            const size = safeFloat(p.positionAmt);
+            const entryPrice = safeFloat(p.entryPrice);
+            const markPrice = safeFloat(p.markPrice);
+            const pnl = safeFloat(p.unRealizedProfit);
+            const leverage = parseInt(p.leverage, 10) || 1;
+            const positionValue = Math.abs(size) * entryPrice;
+            return {
+                exchange: 'binance',
+                symbol: p.symbol,
+                side: (size > 0 ? 'LONG' : 'SHORT'),
+                size: Math.abs(size),
+                entryPrice,
+                markPrice,
+                liquidationPrice: safeFloat(p.liquidationPrice),
+                leverage,
+                marginType: p.marginType.toUpperCase(),
+                unrealizedPnl: pnl,
+                unrealizedPnlPct: positionValue > 0 ? (pnl / positionValue) * 100 : 0,
+                margin: safeFloat(p.isolatedMargin) || (leverage > 0 ? positionValue / leverage : 0),
+                timestamp: Date.now(),
+            };
+        });
+    }
+    async setLeverage(symbol, leverage) {
+        await this.request('POST', '/fapi/v1/leverage', { symbol, leverage }, true);
+    }
+    async setMarginType(symbol, marginType) {
+        try {
+            await this.request('POST', '/fapi/v1/marginType', { symbol, marginType }, true);
+        }
+        catch (err) {
+            const msg = err.message;
+            if (!msg.includes('No need to change'))
+                throw err;
+        }
+    }
+    async placeOrder(order) {
+        if (this.dryRun) {
+            logger_1.logger.info({ order }, '[DRY RUN] Would place Binance futures order');
+            return this.createDryRunOrder(order);
+        }
+        if (order.leverage) {
+            await this.setLeverage(order.symbol, order.leverage);
+        }
+        const params = {
+            symbol: order.symbol,
+            side: order.side,
+            type: order.type,
+            quantity: order.size,
+        };
+        if (order.price && order.type === 'LIMIT') {
+            params.price = order.price;
+            params.timeInForce = 'GTC';
+        }
+        if (order.stopPrice) {
+            params.stopPrice = order.stopPrice;
+        }
+        if (order.reduceOnly) {
+            params.reduceOnly = 'true';
+        }
+        const result = await this.request('POST', '/fapi/v1/order', params, true);
+        const mainOrder = {
+            id: String(result.orderId),
+            exchange: 'binance',
+            symbol: result.symbol,
+            side: result.side,
+            type: result.type,
+            size: parseFloat(result.origQty),
+            leverage: order.leverage || 1,
+            reduceOnly: order.reduceOnly || false,
+            status: result.status,
+            filledSize: parseFloat(result.executedQty),
+            avgFillPrice: parseFloat(result.avgPrice),
+            timestamp: result.updateTime,
+        };
+        // Place TP/SL orders if specified — don't let failures lose the main order
+        try {
+            if (order.takeProfit) {
+                await this.request('POST', '/fapi/v1/order', {
+                    symbol: order.symbol,
+                    side: order.side === 'BUY' ? 'SELL' : 'BUY',
+                    type: 'TAKE_PROFIT_MARKET',
+                    stopPrice: order.takeProfit,
+                    closePosition: 'true',
+                }, true);
+            }
+        }
+        catch (err) {
+            logger_1.logger.error({ err, symbol: order.symbol, takeProfit: order.takeProfit }, 'Failed to place take-profit order (main order succeeded)');
+        }
+        try {
+            if (order.stopLoss) {
+                await this.request('POST', '/fapi/v1/order', {
+                    symbol: order.symbol,
+                    side: order.side === 'BUY' ? 'SELL' : 'BUY',
+                    type: 'STOP_MARKET',
+                    stopPrice: order.stopLoss,
+                    closePosition: 'true',
+                }, true);
+            }
+        }
+        catch (err) {
+            logger_1.logger.error({ err, symbol: order.symbol, stopLoss: order.stopLoss }, 'Failed to place stop-loss order (main order succeeded)');
+        }
+        return mainOrder;
+    }
+    createDryRunOrder(order) {
+        const isMarket = order.type === 'MARKET';
+        return {
+            id: `dry-${Date.now()}-${(0, crypto_1.randomBytes)(4).toString('hex')}`,
+            exchange: 'binance',
+            symbol: order.symbol,
+            side: order.side,
+            type: order.type,
+            size: order.size,
+            price: order.price,
+            leverage: order.leverage || 1,
+            reduceOnly: order.reduceOnly || false,
+            status: isMarket ? 'FILLED' : 'NEW',
+            filledSize: isMarket ? order.size : 0,
+            avgFillPrice: isMarket ? (order.price || 0) : 0,
+            timestamp: Date.now(),
+        };
+    }
+    async cancelOrder(symbol, orderId) {
+        await this.request('DELETE', '/fapi/v1/order', { symbol, orderId }, true);
+    }
+    async closePosition(symbol) {
+        const positions = await this.getPositions();
+        const position = positions.find(p => p.symbol === symbol);
+        if (!position)
+            return null;
+        return this.placeOrder({
+            symbol,
+            side: position.side === 'LONG' ? 'SELL' : 'BUY',
+            type: 'MARKET',
+            size: position.size,
+            reduceOnly: true,
+        });
+    }
+    async getMarkets() {
+        const [exchangeInfo, tickers, fundingRates] = await Promise.all([
+            this.request('GET', '/fapi/v1/exchangeInfo'),
+            this.request('GET', '/fapi/v1/ticker/24hr'),
+            this.request('GET', '/fapi/v1/premiumIndex'),
+        ]);
+        const tickerMap = new Map(tickers.map(t => [t.symbol, t]));
+        const fundingMap = new Map(fundingRates.map(f => [f.symbol, f]));
+        return exchangeInfo.symbols
+            .filter(s => s.quoteAsset === 'USDT')
+            .map(s => {
+            const ticker = tickerMap.get(s.symbol);
+            const funding = fundingMap.get(s.symbol);
+            const priceFilter = s.filters.find(f => f.filterType === 'PRICE_FILTER');
+            const lotFilter = s.filters.find(f => f.filterType === 'LOT_SIZE');
+            const notionalFilter = s.filters.find(f => f.filterType === 'MIN_NOTIONAL');
+            return {
+                exchange: 'binance',
+                symbol: s.symbol,
+                baseAsset: s.baseAsset,
+                quoteAsset: s.quoteAsset,
+                tickSize: parseFloat(priceFilter?.tickSize || '0.01'),
+                lotSize: parseFloat(lotFilter?.stepSize || '0.001'),
+                minNotional: parseFloat(notionalFilter?.notional || '5'),
+                maxLeverage: 125,
+                fundingRate: parseFloat(funding?.lastFundingRate || '0') * 100,
+                markPrice: parseFloat(funding?.markPrice || ticker?.lastPrice || '0'),
+                indexPrice: parseFloat(funding?.indexPrice || '0'),
+                volume24h: parseFloat(ticker?.volume || '0'),
+            };
+        });
+    }
+    async getFundingRate(symbol) {
+        const data = await this.request('GET', '/fapi/v1/premiumIndex', { symbol });
+        return {
+            rate: parseFloat(data.lastFundingRate) * 100,
+            nextFundingTime: data.nextFundingTime,
+        };
+    }
+    async getOpenOrders(symbol) {
+        const params = {};
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/fapi/v1/openOrders', params, true);
+        return data.map(o => ({
+            id: String(o.orderId),
+            exchange: 'binance',
+            symbol: o.symbol,
+            side: o.side,
+            type: o.type,
+            size: parseFloat(o.origQty),
+            price: parseFloat(o.price),
+            leverage: 1,
+            reduceOnly: false,
+            status: o.status,
+            filledSize: parseFloat(o.executedQty),
+            avgFillPrice: parseFloat(o.price),
+            timestamp: o.time,
+        }));
+    }
+    // =========== ADDITIONAL COMPREHENSIVE METHODS ===========
+    async getAccountInfo() {
+        const data = await this.request('GET', '/fapi/v2/account', {}, true);
+        const positions = data.positions
+            .filter(p => safeFloat(p.positionAmt) !== 0)
+            .map(p => {
+            const size = safeFloat(p.positionAmt);
+            const entryPrice = safeFloat(p.entryPrice);
+            const markPrice = safeFloat(p.markPrice);
+            const pnl = safeFloat(p.unRealizedProfit);
+            return {
+                exchange: 'binance',
+                symbol: p.symbol,
+                side: (size > 0 ? 'LONG' : 'SHORT'),
+                size: Math.abs(size),
+                entryPrice,
+                markPrice,
+                liquidationPrice: safeFloat(p.liquidationPrice),
+                leverage: parseInt(p.leverage, 10) || 1,
+                marginType: p.marginType.toUpperCase(),
+                unrealizedPnl: pnl,
+                unrealizedPnlPct: Math.abs(size) * entryPrice > 0 ? (pnl / (Math.abs(size) * entryPrice)) * 100 : 0,
+                margin: safeFloat(p.isolatedMargin),
+                timestamp: Date.now(),
+            };
+        });
+        return {
+            exchange: 'binance',
+            totalWalletBalance: safeFloat(data.totalWalletBalance),
+            totalUnrealizedProfit: safeFloat(data.totalUnrealizedProfit),
+            totalMarginBalance: safeFloat(data.totalMarginBalance),
+            totalPositionInitialMargin: safeFloat(data.totalPositionInitialMargin),
+            totalOpenOrderInitialMargin: safeFloat(data.totalOpenOrderInitialMargin),
+            availableBalance: safeFloat(data.availableBalance),
+            maxWithdrawAmount: safeFloat(data.maxWithdrawAmount),
+            canTrade: data.canTrade,
+            canDeposit: data.canDeposit,
+            canWithdraw: data.canWithdraw,
+            positions,
+        };
+    }
+    async getTradeHistory(symbol, limit = 500) {
+        const data = await this.request('GET', '/fapi/v1/userTrades', { symbol, limit }, true);
+        return data.map(t => ({
+            id: String(t.id),
+            exchange: 'binance',
+            symbol: t.symbol,
+            orderId: String(t.orderId),
+            side: t.side,
+            price: parseFloat(t.price),
+            quantity: parseFloat(t.qty),
+            realizedPnl: parseFloat(t.realizedPnl),
+            commission: parseFloat(t.commission),
+            commissionAsset: t.commissionAsset,
+            timestamp: t.time,
+            isMaker: t.maker,
+        }));
+    }
+    async getOrderHistory(symbol, limit = 500) {
+        const params = { limit };
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/fapi/v1/allOrders', params, true);
+        return data.map(o => ({
+            id: String(o.orderId),
+            exchange: 'binance',
+            symbol: o.symbol,
+            side: o.side,
+            type: o.type,
+            size: parseFloat(o.origQty),
+            price: parseFloat(o.price),
+            leverage: 1,
+            reduceOnly: o.reduceOnly,
+            status: o.status,
+            filledSize: parseFloat(o.executedQty),
+            avgFillPrice: parseFloat(o.avgPrice),
+            timestamp: o.time,
+        }));
+    }
+    async getKlines(symbol, interval, limit = 500) {
+        const data = await this.request('GET', '/fapi/v1/klines', { symbol, interval, limit });
+        return data.map(k => ({
+            openTime: k[0],
+            open: parseFloat(k[1]),
+            high: parseFloat(k[2]),
+            low: parseFloat(k[3]),
+            close: parseFloat(k[4]),
+            volume: parseFloat(k[5]),
+            closeTime: k[6],
+            quoteVolume: parseFloat(k[7]),
+            trades: k[8],
+            takerBuyVolume: parseFloat(k[9]),
+            takerBuyQuoteVolume: parseFloat(k[10]),
+        }));
+    }
+    async getOrderBook(symbol, limit = 100) {
+        const data = await this.request('GET', '/fapi/v1/depth', { symbol, limit });
+        return {
+            exchange: 'binance',
+            symbol,
+            lastUpdateId: data.lastUpdateId,
+            bids: data.bids.map(([p, q]) => [parseFloat(p), parseFloat(q)]),
+            asks: data.asks.map(([p, q]) => [parseFloat(p), parseFloat(q)]),
+            timestamp: Date.now(),
+        };
+    }
+    async getIncomeHistory(symbol, incomeType, limit = 1000) {
+        const params = { limit };
+        if (symbol)
+            params.symbol = symbol;
+        if (incomeType)
+            params.incomeType = incomeType;
+        const data = await this.request('GET', '/fapi/v1/income', params, true);
+        return data.map(i => ({
+            symbol: i.symbol,
+            incomeType: i.incomeType,
+            income: parseFloat(i.income),
+            asset: i.asset,
+            timestamp: i.time,
+            tradeId: i.tradeId,
+        }));
+    }
+    async getLeverageBrackets(symbol) {
+        const params = {};
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/fapi/v1/leverageBracket', params, true);
+        return data.map(lb => ({
+            symbol: lb.symbol,
+            brackets: lb.brackets,
+        }));
+    }
+    async getPositionMarginHistory(symbol, limit = 500) {
+        const data = await this.request('GET', '/fapi/v1/positionMargin/history', { symbol, limit }, true);
+        return data.map(h => ({
+            symbol: h.symbol,
+            type: h.type,
+            amount: parseFloat(h.deltaAmount),
+            asset: h.asset,
+            timestamp: h.time,
+            positionSide: h.positionSide,
+        }));
+    }
+    async modifyPositionMargin(symbol, amount, type) {
+        // type: 1 = add, 2 = reduce
+        await this.request('POST', '/fapi/v1/positionMargin', { symbol, amount, type }, true);
+    }
+    async placeBatchOrders(orders) {
+        if (this.dryRun) {
+            return orders.map(o => this.createDryRunOrder(o));
+        }
+        const batchOrders = orders.map(order => ({
+            symbol: order.symbol,
+            side: order.side,
+            type: order.type,
+            quantity: String(order.size),
+            price: order.price ? String(order.price) : undefined,
+            stopPrice: order.stopPrice ? String(order.stopPrice) : undefined,
+            reduceOnly: order.reduceOnly ? 'true' : undefined,
+            timeInForce: order.type === 'LIMIT' ? 'GTC' : undefined,
+        }));
+        const result = await this.request('POST', '/fapi/v1/batchOrders', {
+            batchOrders: JSON.stringify(batchOrders),
+        }, true);
+        return result.map((r, i) => ({
+            id: String(r.orderId),
+            exchange: 'binance',
+            symbol: r.symbol,
+            side: r.side,
+            type: r.type,
+            size: parseFloat(r.origQty),
+            leverage: orders[i].leverage || 1,
+            reduceOnly: orders[i].reduceOnly || false,
+            status: r.status,
+            filledSize: parseFloat(r.executedQty),
+            avgFillPrice: parseFloat(r.avgPrice),
+            timestamp: r.updateTime,
+        }));
+    }
+    async cancelAllOrders(symbol) {
+        await this.request('DELETE', '/fapi/v1/allOpenOrders', { symbol }, true);
+    }
+    async getTickerPrice(symbol) {
+        const params = {};
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/fapi/v2/ticker/price', params);
+        const tickers = Array.isArray(data) ? data : [data];
+        return tickers.map(t => ({
+            symbol: t.symbol,
+            price: parseFloat(t.price),
+            timestamp: t.time,
+        }));
+    }
+    async getFundingHistory(symbol, limit = 100) {
+        const data = await this.request('GET', '/fapi/v1/fundingRate', { symbol, limit });
+        return data.map(f => ({
+            symbol: f.symbol,
+            fundingRate: parseFloat(f.fundingRate) * 100,
+            fundingTime: f.fundingTime,
+            markPrice: f.markPrice ? parseFloat(f.markPrice) : undefined,
+        }));
+    }
+    async setPositionMode(dualSidePosition) {
+        await this.request('POST', '/fapi/v1/positionSide/dual', { dualSidePosition: String(dualSidePosition) }, true);
+    }
+    async getPositionMode() {
+        const data = await this.request('GET', '/fapi/v1/positionSide/dual', {}, true);
+        return data.dualSidePosition;
+    }
+    async modifyOrder(symbol, orderId, quantity, price) {
+        const params = { symbol, orderId };
+        if (quantity)
+            params.quantity = quantity;
+        if (price)
+            params.price = price;
+        const result = await this.request('PUT', '/fapi/v1/order', params, true);
+        return {
+            id: String(result.orderId),
+            exchange: 'binance',
+            symbol: result.symbol,
+            side: result.side,
+            type: result.type,
+            size: parseFloat(result.origQty),
+            leverage: 1,
+            reduceOnly: false,
+            status: result.status,
+            filledSize: parseFloat(result.executedQty),
+            avgFillPrice: parseFloat(result.avgPrice),
+            timestamp: result.updateTime,
+        };
+    }
+    async getForceOrders(symbol, limit = 50) {
+        const params = { limit };
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/fapi/v1/forceOrders', params, true);
+        return data.map(o => ({
+            orderId: String(o.orderId),
+            symbol: o.symbol,
+            side: o.side,
+            price: parseFloat(o.price),
+            quantity: parseFloat(o.origQty),
+            status: o.status,
+            timestamp: o.time,
+        }));
+    }
+    async getCommissionRate(symbol) {
+        const data = await this.request('GET', '/fapi/v1/commissionRate', { symbol }, true);
+        return {
+            symbol: data.symbol,
+            makerCommission: parseFloat(data.makerCommissionRate) * 100,
+            takerCommission: parseFloat(data.takerCommissionRate) * 100,
+        };
+    }
+    async createListenKey() {
+        const data = await this.request('POST', '/fapi/v1/listenKey', {}, true);
+        return data.listenKey;
+    }
+    async keepAliveListenKey() {
+        await this.request('PUT', '/fapi/v1/listenKey', {}, true);
+    }
+    async deleteListenKey() {
+        await this.request('DELETE', '/fapi/v1/listenKey', {}, true);
+    }
+    // =========== ADDITIONAL MARKET DATA & ANALYTICS ===========
+    async getServerTime() {
+        const data = await this.request('GET', '/fapi/v1/time');
+        return data.serverTime;
+    }
+    async ping() {
+        await this.request('GET', '/fapi/v1/ping');
+        return true;
+    }
+    async getExchangeInfo() {
+        return this.request('GET', '/fapi/v1/exchangeInfo');
+    }
+    async getRecentTrades(symbol, limit = 500) {
+        const data = await this.request('GET', '/fapi/v1/trades', { symbol, limit });
+        return data.map(t => ({
+            id: t.id,
+            price: parseFloat(t.price),
+            qty: parseFloat(t.qty),
+            quoteQty: parseFloat(t.quoteQty),
+            time: t.time,
+            isBuyerMaker: t.isBuyerMaker,
+        }));
+    }
+    async getAggTrades(symbol, limit = 500) {
+        const data = await this.request('GET', '/fapi/v1/aggTrades', { symbol, limit });
+        return data.map(t => ({
+            aggTradeId: t.a,
+            price: parseFloat(t.p),
+            quantity: parseFloat(t.q),
+            firstTradeId: t.f,
+            lastTradeId: t.l,
+            timestamp: t.T,
+            isBuyerMaker: t.m,
+        }));
+    }
+    async getContinuousKlines(pair, contractType, interval, limit = 500) {
+        const data = await this.request('GET', '/fapi/v1/continuousKlines', { pair, contractType, interval, limit });
+        return data.map(k => ({
+            openTime: k[0],
+            open: parseFloat(k[1]),
+            high: parseFloat(k[2]),
+            low: parseFloat(k[3]),
+            close: parseFloat(k[4]),
+            volume: parseFloat(k[5]),
+            closeTime: k[6],
+            quoteVolume: parseFloat(k[7]),
+            trades: k[8],
+            takerBuyVolume: parseFloat(k[9]),
+            takerBuyQuoteVolume: parseFloat(k[10]),
+        }));
+    }
+    async getIndexPriceKlines(pair, interval, limit = 500) {
+        const data = await this.request('GET', '/fapi/v1/indexPriceKlines', { pair, interval, limit });
+        return data.map(k => ({
+            openTime: k[0],
+            open: parseFloat(k[1]),
+            high: parseFloat(k[2]),
+            low: parseFloat(k[3]),
+            close: parseFloat(k[4]),
+            volume: 0,
+            closeTime: k[6],
+            quoteVolume: 0,
+            trades: 0,
+            takerBuyVolume: 0,
+            takerBuyQuoteVolume: 0,
+        }));
+    }
+    async getMarkPriceKlines(symbol, interval, limit = 500) {
+        const data = await this.request('GET', '/fapi/v1/markPriceKlines', { symbol, interval, limit });
+        return data.map(k => ({
+            openTime: k[0],
+            open: parseFloat(k[1]),
+            high: parseFloat(k[2]),
+            low: parseFloat(k[3]),
+            close: parseFloat(k[4]),
+            volume: 0,
+            closeTime: k[6],
+            quoteVolume: 0,
+            trades: 0,
+            takerBuyVolume: 0,
+            takerBuyQuoteVolume: 0,
+        }));
+    }
+    async get24hrTicker(symbol) {
+        const params = {};
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/fapi/v1/ticker/24hr', params);
+        const tickers = Array.isArray(data) ? data : [data];
+        return tickers.map(t => ({
+            symbol: t.symbol,
+            priceChange: parseFloat(t.priceChange),
+            priceChangePercent: parseFloat(t.priceChangePercent),
+            weightedAvgPrice: parseFloat(t.weightedAvgPrice),
+            lastPrice: parseFloat(t.lastPrice),
+            lastQty: parseFloat(t.lastQty),
+            openPrice: parseFloat(t.openPrice),
+            highPrice: parseFloat(t.highPrice),
+            lowPrice: parseFloat(t.lowPrice),
+            volume: parseFloat(t.volume),
+            quoteVolume: parseFloat(t.quoteVolume),
+            openTime: t.openTime,
+            closeTime: t.closeTime,
+            count: t.count,
+        }));
+    }
+    async getBookTicker(symbol) {
+        const params = {};
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/fapi/v1/ticker/bookTicker', params);
+        const tickers = Array.isArray(data) ? data : [data];
+        return tickers.map(t => ({
+            symbol: t.symbol,
+            bidPrice: parseFloat(t.bidPrice),
+            bidQty: parseFloat(t.bidQty),
+            askPrice: parseFloat(t.askPrice),
+            askQty: parseFloat(t.askQty),
+            time: t.time,
+        }));
+    }
+    async getOpenInterest(symbol) {
+        const data = await this.request('GET', '/fapi/v1/openInterest', { symbol });
+        return {
+            symbol: data.symbol,
+            openInterest: parseFloat(data.openInterest),
+            time: data.time,
+        };
+    }
+    async getOpenInterestHistory(symbol, period, limit = 30) {
+        const data = await this.request('GET', '/futures/data/openInterestHist', { symbol, period, limit });
+        return data.map(d => ({
+            symbol: d.symbol,
+            sumOpenInterest: parseFloat(d.sumOpenInterest),
+            sumOpenInterestValue: parseFloat(d.sumOpenInterestValue),
+            timestamp: d.timestamp,
+        }));
+    }
+    async getTopTraderLongShortRatio(symbol, period, limit = 30) {
+        const data = await this.request('GET', '/futures/data/topLongShortAccountRatio', { symbol, period, limit });
+        return data.map(d => ({
+            symbol: d.symbol,
+            longShortRatio: parseFloat(d.longShortRatio),
+            longAccount: parseFloat(d.longAccount),
+            shortAccount: parseFloat(d.shortAccount),
+            timestamp: d.timestamp,
+        }));
+    }
+    async getGlobalLongShortRatio(symbol, period, limit = 30) {
+        const data = await this.request('GET', '/futures/data/globalLongShortAccountRatio', { symbol, period, limit });
+        return data.map(d => ({
+            symbol: d.symbol,
+            longShortRatio: parseFloat(d.longShortRatio),
+            longAccount: parseFloat(d.longAccount),
+            shortAccount: parseFloat(d.shortAccount),
+            timestamp: d.timestamp,
+        }));
+    }
+    async getTakerBuySellVolume(symbol, period, limit = 30) {
+        const data = await this.request('GET', '/futures/data/takerlongshortRatio', { symbol, period, limit });
+        return data.map(d => ({
+            buySellRatio: parseFloat(d.buySellRatio),
+            buyVol: parseFloat(d.buyVol),
+            sellVol: parseFloat(d.sellVol),
+            timestamp: d.timestamp,
+        }));
+    }
+    async getFundingInfo() {
+        const data = await this.request('GET', '/fapi/v1/fundingInfo');
+        return data.map(f => ({
+            symbol: f.symbol,
+            adjustedFundingRateCap: parseFloat(f.adjustedFundingRateCap),
+            adjustedFundingRateFloor: parseFloat(f.adjustedFundingRateFloor),
+            fundingIntervalHours: f.fundingIntervalHours,
+        }));
+    }
+    async getADLQuantile(symbol) {
+        const params = {};
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/fapi/v1/adlQuantile', params, true);
+        return data;
+    }
+    async setMultiAssetsMode(multiAssetsMargin) {
+        await this.request('POST', '/fapi/v1/multiAssetsMargin', { multiAssetsMargin: String(multiAssetsMargin) }, true);
+    }
+    async getMultiAssetsMode() {
+        const data = await this.request('GET', '/fapi/v1/multiAssetsMargin', {}, true);
+        return data.multiAssetsMargin;
+    }
+    async testOrder(order) {
+        const params = {
+            symbol: order.symbol,
+            side: order.side,
+            type: order.type,
+            quantity: order.size,
+        };
+        if (order.price)
+            params.price = order.price;
+        if (order.stopPrice)
+            params.stopPrice = order.stopPrice;
+        await this.request('POST', '/fapi/v1/order/test', params, true);
+    }
+    async setAutoCancel(symbol, countdownTime) {
+        const data = await this.request('POST', '/fapi/v1/countdownCancelAll', { symbol, countdownTime }, true);
+        return { symbol: data.symbol, countdownTime: parseInt(data.countdownTime) };
+    }
+    async getOrderModifyHistory(symbol, orderId, limit = 50) {
+        const params = { symbol, limit };
+        if (orderId)
+            params.orderId = orderId;
+        const data = await this.request('GET', '/fapi/v1/orderAmendment', params, true);
+        return data.map(d => ({
+            symbol: d.symbol,
+            orderId: d.orderId,
+            amendmentId: d.amendmentId,
+            time: d.time,
+            amendment: {
+                price: { before: parseFloat(d.amendment.price.before), after: parseFloat(d.amendment.price.after) },
+                origQty: { before: parseFloat(d.amendment.origQty.before), after: parseFloat(d.amendment.origQty.after) },
+            },
+        }));
+    }
+    async getSymbolConfig(symbol) {
+        const params = {};
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/fapi/v1/symbolConfig', params, true);
+        return data.map(c => ({
+            symbol: c.symbol,
+            marginType: c.marginType,
+            isAutoAddMargin: c.isAutoAddMargin,
+            leverage: c.leverage,
+            maxNotionalValue: parseFloat(c.maxNotionalValue),
+        }));
+    }
+    async getOrderRateLimit() {
+        return this.request('GET', '/fapi/v1/rateLimit/order', {}, true);
+    }
+}
+exports.BinanceFuturesClient = BinanceFuturesClient;
+// =============================================================================
+// BYBIT FUTURES CLIENT
+// =============================================================================
+class BybitFuturesClient {
+    apiKey;
+    apiSecret;
+    baseUrl;
+    dryRun;
+    recvWindow = 5000;
+    constructor(credentials, dryRun = false) {
+        this.apiKey = credentials.apiKey;
+        this.apiSecret = credentials.apiSecret;
+        this.baseUrl = credentials.testnet
+            ? 'https://api-testnet.bybit.com'
+            : 'https://api.bybit.com';
+        this.dryRun = dryRun;
+    }
+    sign(timestamp, params) {
+        const payload = `${timestamp}${this.apiKey}${this.recvWindow}${params}`;
+        return (0, crypto_1.createHmac)('sha256', this.apiSecret).update(payload).digest('hex');
+    }
+    async request(method, endpoint, params = {}) {
+        const timestamp = Date.now();
+        let queryString = '';
+        let body = '';
+        if (method === 'GET') {
+            queryString = Object.entries(params)
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([k, v]) => `${k}=${v}`)
+                .join('&');
+        }
+        else {
+            body = JSON.stringify(params);
+        }
+        const signature = this.sign(timestamp, method === 'GET' ? queryString : body);
+        const url = new URL(endpoint, this.baseUrl);
+        if (method === 'GET' && queryString) {
+            url.search = queryString;
+        }
+        const response = await fetchWithRetry(url.toString(), {
+            method,
+            headers: {
+                'X-BAPI-API-KEY': this.apiKey,
+                'X-BAPI-SIGN': signature,
+                'X-BAPI-TIMESTAMP': String(timestamp),
+                'X-BAPI-RECV-WINDOW': String(this.recvWindow),
+                'Content-Type': 'application/json',
+            },
+            body: method === 'POST' ? body : undefined,
+            signal: AbortSignal.timeout(30_000),
+        });
+        const data = await response.json();
+        if (data.retCode !== 0) {
+            throw new Error(`Bybit error: ${data.retMsg}`);
+        }
+        return data.result;
+    }
+    async getBalance() {
+        const data = await this.request('GET', '/v5/account/wallet-balance', {
+            accountType: 'UNIFIED',
+        });
+        const account = data.list[0];
+        const usdt = account?.coin?.find(c => c.coin === 'USDT') || {
+            availableToWithdraw: '0',
+            walletBalance: '0',
+            unrealisedPnl: '0',
+        };
+        return {
+            exchange: 'bybit',
+            asset: 'USDT',
+            available: safeFloat(usdt.availableToWithdraw),
+            total: safeFloat(usdt.walletBalance),
+            unrealizedPnl: safeFloat(usdt.unrealisedPnl),
+            marginBalance: safeFloat(usdt.walletBalance),
+        };
+    }
+    async getPositions() {
+        const data = await this.request('GET', '/v5/position/list', {
+            category: 'linear',
+            settleCoin: 'USDT',
+        });
+        return data.list
+            .filter(p => safeFloat(p.size) > 0)
+            .map(p => {
+            const size = safeFloat(p.size);
+            const entryPrice = safeFloat(p.avgPrice);
+            const markPrice = safeFloat(p.markPrice);
+            const pnl = safeFloat(p.unrealisedPnl);
+            const positionValue = size * entryPrice;
+            return {
+                exchange: 'bybit',
+                symbol: p.symbol,
+                side: (p.side === 'Buy' ? 'LONG' : 'SHORT'),
+                size,
+                entryPrice,
+                markPrice,
+                liquidationPrice: safeFloat(p.liqPrice),
+                leverage: parseInt(p.leverage, 10) || 1,
+                marginType: (p.tradeMode === 0 ? 'CROSS' : 'ISOLATED'),
+                unrealizedPnl: pnl,
+                unrealizedPnlPct: positionValue > 0 ? (pnl / positionValue) * 100 : 0,
+                margin: safeFloat(p.positionIM),
+                timestamp: Date.now(),
+            };
+        });
+    }
+    async setLeverage(symbol, leverage) {
+        try {
+            await this.request('POST', '/v5/position/set-leverage', {
+                category: 'linear',
+                symbol,
+                buyLeverage: String(leverage),
+                sellLeverage: String(leverage),
+            });
+        }
+        catch (err) {
+            const msg = err.message;
+            if (!msg.includes('leverage not modified'))
+                throw err;
+        }
+    }
+    async placeOrder(order) {
+        if (this.dryRun) {
+            logger_1.logger.info({ order }, '[DRY RUN] Would place Bybit futures order');
+            return this.createDryRunOrder(order);
+        }
+        if (order.leverage) {
+            await this.setLeverage(order.symbol, order.leverage);
+        }
+        const isStopOrder = order.type === 'STOP_MARKET' || order.type === 'TAKE_PROFIT_MARKET';
+        const params = {
+            category: 'linear',
+            symbol: order.symbol,
+            side: order.side === 'BUY' ? 'Buy' : 'Sell',
+            orderType: (order.type === 'MARKET' || isStopOrder) ? 'Market' : 'Limit',
+            qty: String(order.size),
+        };
+        if (order.price && order.type === 'LIMIT') {
+            params.price = String(order.price);
+        }
+        if (order.reduceOnly || isStopOrder) {
+            params.reduceOnly = true;
+        }
+        // Set trigger price for stop/TP orders
+        if (isStopOrder && order.stopPrice) {
+            params.triggerPrice = String(order.stopPrice);
+            params.triggerBy = 'MarkPrice';
+        }
+        if (order.takeProfit) {
+            params.takeProfit = String(order.takeProfit);
+        }
+        if (order.stopLoss) {
+            params.stopLoss = String(order.stopLoss);
+        }
+        const result = await this.request('POST', '/v5/order/create', params);
+        return {
+            id: result.orderId,
+            exchange: 'bybit',
+            symbol: order.symbol,
+            side: order.side,
+            type: order.type,
+            size: order.size,
+            price: order.price,
+            stopPrice: order.stopPrice,
+            leverage: order.leverage || 1,
+            reduceOnly: order.reduceOnly || isStopOrder,
+            status: 'NEW',
+            filledSize: 0,
+            avgFillPrice: 0,
+            timestamp: Date.now(),
+        };
+    }
+    createDryRunOrder(order) {
+        const isMarket = order.type === 'MARKET';
+        return {
+            id: `dry-${Date.now()}-${(0, crypto_1.randomBytes)(4).toString('hex')}`,
+            exchange: 'bybit',
+            symbol: order.symbol,
+            side: order.side,
+            type: order.type,
+            size: order.size,
+            price: order.price,
+            leverage: order.leverage || 1,
+            reduceOnly: order.reduceOnly || false,
+            status: isMarket ? 'FILLED' : 'NEW',
+            filledSize: isMarket ? order.size : 0,
+            avgFillPrice: isMarket ? (order.price || 0) : 0,
+            timestamp: Date.now(),
+        };
+    }
+    async cancelOrder(symbol, orderId) {
+        await this.request('POST', '/v5/order/cancel', {
+            category: 'linear',
+            symbol,
+            orderId,
+        });
+    }
+    async closePosition(symbol) {
+        const positions = await this.getPositions();
+        const position = positions.find(p => p.symbol === symbol);
+        if (!position)
+            return null;
+        return this.placeOrder({
+            symbol,
+            side: position.side === 'LONG' ? 'SELL' : 'BUY',
+            type: 'MARKET',
+            size: position.size,
+            reduceOnly: true,
+        });
+    }
+    async getMarkets() {
+        const [instruments, tickers] = await Promise.all([
+            this.request('GET', '/v5/market/instruments-info', { category: 'linear' }),
+            this.request('GET', '/v5/market/tickers', { category: 'linear' }),
+        ]);
+        const tickerMap = new Map(tickers.list.map(t => [t.symbol, t]));
+        return instruments.list
+            .filter(i => i.quoteCoin === 'USDT')
+            .map(i => {
+            const ticker = tickerMap.get(i.symbol);
+            return {
+                exchange: 'bybit',
+                symbol: i.symbol,
+                baseAsset: i.baseCoin,
+                quoteAsset: i.quoteCoin,
+                tickSize: parseFloat(i.priceFilter.tickSize),
+                lotSize: parseFloat(i.lotSizeFilter.qtyStep),
+                minNotional: parseFloat(i.lotSizeFilter.minOrderQty),
+                maxLeverage: parseInt(i.leverageFilter.maxLeverage),
+                fundingRate: parseFloat(ticker?.fundingRate || '0') * 100,
+                markPrice: parseFloat(ticker?.markPrice || '0'),
+                indexPrice: parseFloat(ticker?.indexPrice || '0'),
+                volume24h: parseFloat(ticker?.volume24h || '0'),
+            };
+        });
+    }
+    async getFundingRate(symbol) {
+        const data = await this.request('GET', '/v5/market/tickers', {
+            category: 'linear',
+            symbol,
+        });
+        const ticker = data.list[0];
+        return {
+            rate: parseFloat(ticker?.fundingRate || '0') * 100,
+            nextFundingTime: parseInt(ticker?.nextFundingTime || '0'),
+        };
+    }
+    async getOpenOrders(symbol) {
+        const params = { category: 'linear' };
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/v5/order/realtime', params);
+        return data.list.map(o => ({
+            id: o.orderId,
+            exchange: 'bybit',
+            symbol: o.symbol,
+            side: (o.side === 'Buy' ? 'BUY' : 'SELL'),
+            type: (o.orderType === 'Market' ? 'MARKET' : 'LIMIT'),
+            size: parseFloat(o.qty),
+            price: parseFloat(o.price),
+            leverage: 1,
+            reduceOnly: false,
+            status: this.mapBybitStatus(o.orderStatus),
+            filledSize: parseFloat(o.cumExecQty),
+            avgFillPrice: parseFloat(o.price),
+            timestamp: parseInt(o.createdTime),
+        }));
+    }
+    mapBybitStatus(status) {
+        const statusMap = {
+            'New': 'NEW',
+            'PartiallyFilled': 'PARTIALLY_FILLED',
+            'Filled': 'FILLED',
+            'Cancelled': 'CANCELED',
+            'Rejected': 'REJECTED',
+        };
+        return statusMap[status] || 'NEW';
+    }
+    // =========== ADDITIONAL COMPREHENSIVE METHODS ===========
+    async getAccountInfo() {
+        const data = await this.request('GET', '/v5/account/wallet-balance', { accountType: 'UNIFIED' });
+        const account = data.list[0];
+        const positions = await this.getPositions();
+        return {
+            exchange: 'bybit',
+            totalWalletBalance: safeFloat(account?.totalWalletBalance || '0'),
+            totalUnrealizedProfit: safeFloat(account?.totalPerpUPL || '0'),
+            totalMarginBalance: safeFloat(account?.totalMarginBalance || '0'),
+            totalPositionInitialMargin: safeFloat(account?.totalInitialMargin || '0'),
+            totalOpenOrderInitialMargin: 0,
+            availableBalance: safeFloat(account?.totalAvailableBalance || '0'),
+            maxWithdrawAmount: safeFloat(account?.totalAvailableBalance || '0'),
+            canTrade: true,
+            canDeposit: true,
+            canWithdraw: true,
+            positions,
+        };
+    }
+    async getTradeHistory(symbol, limit = 100) {
+        const params = { category: 'linear', limit };
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/v5/execution/list', params);
+        return data.list.map(t => ({
+            id: t.execId,
+            exchange: 'bybit',
+            symbol: t.symbol,
+            orderId: t.orderId,
+            side: (t.side === 'Buy' ? 'BUY' : 'SELL'),
+            price: parseFloat(t.execPrice),
+            quantity: parseFloat(t.execQty),
+            realizedPnl: parseFloat(t.closedPnl),
+            commission: parseFloat(t.execFee),
+            commissionAsset: t.feeCurrency,
+            timestamp: parseInt(t.execTime),
+            isMaker: t.isMaker,
+        }));
+    }
+    async getOrderHistory(symbol, limit = 50) {
+        const params = { category: 'linear', limit };
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/v5/order/history', params);
+        return data.list.map(o => ({
+            id: o.orderId,
+            exchange: 'bybit',
+            symbol: o.symbol,
+            side: (o.side === 'Buy' ? 'BUY' : 'SELL'),
+            type: (o.orderType === 'Market' ? 'MARKET' : 'LIMIT'),
+            size: parseFloat(o.qty),
+            price: parseFloat(o.price),
+            leverage: 1,
+            reduceOnly: o.reduceOnly,
+            status: this.mapBybitStatus(o.orderStatus),
+            filledSize: parseFloat(o.cumExecQty),
+            avgFillPrice: parseFloat(o.avgPrice),
+            timestamp: parseInt(o.createdTime),
+        }));
+    }
+    async getKlines(symbol, interval, limit = 200) {
+        const data = await this.request('GET', '/v5/market/kline', {
+            category: 'linear',
+            symbol,
+            interval,
+            limit,
+        });
+        return data.list.map(k => ({
+            openTime: parseInt(k[0]),
+            open: parseFloat(k[1]),
+            high: parseFloat(k[2]),
+            low: parseFloat(k[3]),
+            close: parseFloat(k[4]),
+            volume: parseFloat(k[5]),
+            closeTime: parseInt(k[0]) + 60000,
+            quoteVolume: parseFloat(k[6]),
+            trades: 0,
+            takerBuyVolume: 0,
+            takerBuyQuoteVolume: 0,
+        }));
+    }
+    async getOrderBook(symbol, limit = 50) {
+        const data = await this.request('GET', '/v5/market/orderbook', {
+            category: 'linear',
+            symbol,
+            limit,
+        });
+        return {
+            exchange: 'bybit',
+            symbol,
+            lastUpdateId: data.u,
+            bids: data.b.map(([p, q]) => [parseFloat(p), parseFloat(q)]),
+            asks: data.a.map(([p, q]) => [parseFloat(p), parseFloat(q)]),
+            timestamp: data.ts,
+        };
+    }
+    async getIncomeHistory(symbol, limit = 100) {
+        const params = { category: 'linear', limit };
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/v5/position/closed-pnl', params);
+        return data.list.map(i => ({
+            symbol: i.symbol,
+            incomeType: 'REALIZED_PNL',
+            income: parseFloat(i.closedPnl),
+            asset: 'USDT',
+            timestamp: parseInt(i.updatedTime),
+            tradeId: i.orderId,
+        }));
+    }
+    async getRiskLimit(symbol) {
+        const data = await this.request('GET', '/v5/market/risk-limit', {
+            category: 'linear',
+            symbol,
+        });
+        return data.list.map(r => ({
+            symbol: r.symbol,
+            maxLeverage: parseInt(r.maxLeverage),
+            maintenanceMarginRate: parseFloat(r.maintainMargin),
+            riskLimitValue: parseFloat(r.riskLimitValue),
+        }));
+    }
+    async setRiskLimit(symbol, riskId) {
+        await this.request('POST', '/v5/position/set-risk-limit', {
+            category: 'linear',
+            symbol,
+            riskId,
+        });
+    }
+    async amendOrder(symbol, orderId, qty, price) {
+        const params = { category: 'linear', symbol, orderId };
+        if (qty)
+            params.qty = String(qty);
+        if (price)
+            params.price = String(price);
+        const result = await this.request('POST', '/v5/order/amend', params);
+        return {
+            id: result.orderId,
+            exchange: 'bybit',
+            symbol,
+            side: 'BUY',
+            type: 'LIMIT',
+            size: qty || 0,
+            price,
+            leverage: 1,
+            reduceOnly: false,
+            status: 'NEW',
+            filledSize: 0,
+            avgFillPrice: 0,
+            timestamp: Date.now(),
+        };
+    }
+    async cancelAllOrders(symbol) {
+        const params = { category: 'linear' };
+        if (symbol)
+            params.symbol = symbol;
+        await this.request('POST', '/v5/order/cancel-all', params);
+    }
+    async placeBatchOrders(orders) {
+        if (this.dryRun) {
+            return orders.map(o => this.createDryRunOrder(o));
+        }
+        const request = orders.map(order => ({
+            symbol: order.symbol,
+            side: order.side === 'BUY' ? 'Buy' : 'Sell',
+            orderType: order.type === 'MARKET' ? 'Market' : 'Limit',
+            qty: String(order.size),
+            price: order.price ? String(order.price) : undefined,
+            reduceOnly: order.reduceOnly,
+        }));
+        const result = await this.request('POST', '/v5/order/create-batch', {
+            category: 'linear',
+            request,
+        });
+        return result.list.map((r, i) => ({
+            id: r.orderId,
+            exchange: 'bybit',
+            symbol: r.symbol,
+            side: orders[i].side,
+            type: orders[i].type,
+            size: orders[i].size,
+            price: orders[i].price,
+            leverage: orders[i].leverage || 1,
+            reduceOnly: orders[i].reduceOnly || false,
+            status: 'NEW',
+            filledSize: 0,
+            avgFillPrice: 0,
+            timestamp: Date.now(),
+        }));
+    }
+    async getTickerPrice(symbol) {
+        const params = { category: 'linear' };
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/v5/market/tickers', params);
+        return data.list.map(t => ({
+            symbol: t.symbol,
+            price: parseFloat(t.lastPrice),
+            timestamp: Date.now(),
+        }));
+    }
+    async getFundingHistory(symbol, limit = 100) {
+        const data = await this.request('GET', '/v5/market/funding/history', {
+            category: 'linear',
+            symbol,
+            limit,
+        });
+        return data.list.map(f => ({
+            symbol: f.symbol,
+            fundingRate: parseFloat(f.fundingRate) * 100,
+            fundingTime: parseInt(f.fundingRateTimestamp),
+        }));
+    }
+    async setPositionMode(mode) {
+        await this.request('POST', '/v5/position/switch-mode', {
+            category: 'linear',
+            mode,
+        });
+    }
+    async setIsolatedMargin(symbol, tradeMode, leverage) {
+        // 0 = cross, 1 = isolated
+        const lev = String(leverage || 10);
+        await this.request('POST', '/v5/position/switch-isolated', {
+            category: 'linear',
+            symbol,
+            tradeMode,
+            buyLeverage: lev,
+            sellLeverage: lev,
+        });
+    }
+    async modifyPositionMargin(symbol, margin) {
+        await this.request('POST', '/v5/position/add-margin', {
+            category: 'linear',
+            symbol,
+            margin: String(margin),
+        });
+    }
+    async getRecentTrades(symbol, limit = 60) {
+        const data = await this.request('GET', '/v5/market/recent-trade', {
+            category: 'linear',
+            symbol,
+            limit,
+        });
+        return data.list.map(t => ({
+            price: parseFloat(t.price),
+            size: parseFloat(t.size),
+            side: t.side,
+            timestamp: parseInt(t.time),
+        }));
+    }
+    async getServerTime() {
+        const data = await this.request('GET', '/v5/market/time', {});
+        return parseInt(data.timeSecond) * 1000;
+    }
+    // =========== ADDITIONAL BYBIT METHODS ===========
+    async batchAmendOrders(orders) {
+        const request = orders.map(o => ({
+            symbol: o.symbol,
+            orderId: o.orderId,
+            qty: o.qty ? String(o.qty) : undefined,
+            price: o.price ? String(o.price) : undefined,
+        }));
+        const result = await this.request('POST', '/v5/order/amend-batch', { category: 'linear', request });
+        return result.list.map(r => ({ orderId: r.orderId, success: r.code === '0' }));
+    }
+    async batchCancelOrders(orders) {
+        const request = orders.map(o => ({ symbol: o.symbol, orderId: o.orderId }));
+        const result = await this.request('POST', '/v5/order/cancel-batch', { category: 'linear', request });
+        return result.list.map(r => ({ orderId: r.orderId, success: r.code === '0' }));
+    }
+    async setDisconnectProtection(expiryTime) {
+        // DCP: Disconnect Cancel Protection - auto-cancel orders if disconnected
+        await this.request('POST', '/v5/order/disconnected-cancel-all', {
+            timeWindow: expiryTime,
+        });
+    }
+    async getSpotBorrowQuota(symbol, side) {
+        const data = await this.request('GET', '/v5/order/spot-borrow-check', {
+            category: 'spot',
+            symbol,
+            side,
+        });
+        return {
+            symbol: data.symbol,
+            maxTradeQty: parseFloat(data.maxTradeQty),
+            side: data.side,
+            borrowCoin: data.borrowCoin,
+        };
+    }
+    async getOpenInterest(symbol, interval, limit = 50) {
+        const data = await this.request('GET', '/v5/market/open-interest', {
+            category: 'linear',
+            symbol,
+            intervalTime: interval,
+            limit,
+        });
+        return data.list.map(d => ({
+            openInterest: parseFloat(d.openInterest),
+            timestamp: parseInt(d.timestamp),
+        }));
+    }
+    async getLongShortRatio(symbol, period, limit = 50) {
+        const data = await this.request('GET', '/v5/market/account-ratio', {
+            category: 'linear',
+            symbol,
+            period,
+            limit,
+        });
+        return data.list.map(d => ({
+            buyRatio: parseFloat(d.buyRatio),
+            sellRatio: parseFloat(d.sellRatio),
+            timestamp: parseInt(d.timestamp),
+        }));
+    }
+    async getInsurance(coin) {
+        const params = {};
+        if (coin)
+            params.coin = coin;
+        const data = await this.request('GET', '/v5/market/insurance', params);
+        return data.list.map(d => ({
+            coin: d.coin,
+            balance: parseFloat(d.balance),
+            value: parseFloat(d.value),
+        }));
+    }
+    async getVolatility(category, baseCoin, period) {
+        const params = { category };
+        if (baseCoin)
+            params.baseCoin = baseCoin;
+        if (period)
+            params.period = period;
+        const data = await this.request('GET', '/v5/market/historical-volatility', params);
+        return data.map(d => ({
+            period: d.period,
+            value: parseFloat(d.value),
+            time: parseInt(d.time),
+        }));
+    }
+    async getDeliveryPrice(symbol, limit = 50) {
+        const data = await this.request('GET', '/v5/market/delivery-price', {
+            category: 'linear',
+            symbol,
+            limit,
+        });
+        return data.list.map(d => ({
+            symbol: d.symbol,
+            deliveryPrice: parseFloat(d.deliveryPrice),
+            deliveryTime: parseInt(d.deliveryTime),
+        }));
+    }
+    async getPreListingInfo(symbol) {
+        const params = { category: 'linear' };
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/v5/market/prelisting-info', params);
+        return data.list.map(d => ({
+            symbol: d.symbol,
+            auctionPhaseType: d.auctionPhaseType,
+            auctionFeeInfo: {
+                auctionFeeRate: parseFloat(d.auctionFeeInfo.auctionFeeRate),
+                takerFeeRate: parseFloat(d.auctionFeeInfo.takerFeeRate),
+                makerFeeRate: parseFloat(d.auctionFeeInfo.makerFeeRate),
+            },
+        }));
+    }
+    async setTradingStop(symbol, takeProfit, stopLoss, trailingStop, positionIdx) {
+        const params = { category: 'linear', symbol };
+        if (takeProfit !== undefined)
+            params.takeProfit = String(takeProfit);
+        if (stopLoss !== undefined)
+            params.stopLoss = String(stopLoss);
+        if (trailingStop !== undefined)
+            params.trailingStop = String(trailingStop);
+        if (positionIdx !== undefined)
+            params.positionIdx = positionIdx;
+        await this.request('POST', '/v5/position/trading-stop', params);
+    }
+    async getClosedPnL(symbol, limit = 50) {
+        const params = { category: 'linear', limit };
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/v5/position/closed-pnl', params);
+        return data.list.map(d => ({
+            symbol: d.symbol,
+            orderId: d.orderId,
+            side: d.side,
+            qty: parseFloat(d.qty),
+            orderPrice: parseFloat(d.orderPrice),
+            closedPnl: parseFloat(d.closedPnl),
+            createdTime: parseInt(d.createdTime),
+        }));
+    }
+    async movePosition(fromUid, toUid, symbol, side, price, qty) {
+        const data = await this.request('POST', '/v5/position/move-positions', {
+            category: 'linear',
+            fromUid,
+            toUid,
+            list: [{ symbol, side, price: String(price), qty: String(qty) }],
+        });
+        return data.list[0];
+    }
+    async confirmNewRiskLimit(symbol) {
+        await this.request('POST', '/v5/position/confirm-pending-mmr', {
+            category: 'linear',
+            symbol,
+        });
+    }
+    async getFeeRate(symbol) {
+        const params = { category: 'linear' };
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/v5/account/fee-rate', params);
+        return data.list.map(d => ({
+            symbol: d.symbol,
+            takerFeeRate: parseFloat(d.takerFeeRate),
+            makerFeeRate: parseFloat(d.makerFeeRate),
+        }));
+    }
+    async getAccountInfo2() {
+        const data = await this.request('GET', '/v5/account/info', {});
+        return data;
+    }
+    async getTransactionLog(accountType, category, currency, limit) {
+        const params = {};
+        if (accountType)
+            params.accountType = accountType;
+        if (category)
+            params.category = category;
+        if (currency)
+            params.currency = currency;
+        if (limit)
+            params.limit = limit;
+        const data = await this.request('GET', '/v5/account/transaction-log', params);
+        return data.list.map(d => ({
+            symbol: d.symbol,
+            side: d.side,
+            funding: parseFloat(d.funding),
+            orderLinkId: d.orderLinkId,
+            orderId: d.orderId,
+            fee: parseFloat(d.fee),
+            change: parseFloat(d.change),
+            cashFlow: parseFloat(d.cashFlow),
+            transactionTime: parseInt(d.transactionTime),
+            type: d.type,
+        }));
+    }
+}
+exports.BybitFuturesClient = BybitFuturesClient;
+// =============================================================================
+// HYPERLIQUID CLIENT (Decentralized on Arbitrum)
+// =============================================================================
+class HyperliquidClient {
+    walletAddress;
+    privateKey;
+    baseUrl = 'https://api.hyperliquid.xyz';
+    dryRun;
+    assetIndexMap = new Map();
+    constructor(credentials, dryRun = false) {
+        this.walletAddress = credentials.apiKey;
+        this.privateKey = credentials.apiSecret;
+        this.dryRun = dryRun;
+    }
+    async request(endpoint, body) {
+        const response = await fetchWithRetry(`${this.baseUrl}${endpoint}`, {
+            method: body ? 'POST' : 'GET',
+            headers: { 'Content-Type': 'application/json' },
+            body: body ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Hyperliquid error: ${response.status} ${text}`);
+        }
+        return response.json();
+    }
+    async ensureAssetIndex() {
+        if (this.assetIndexMap.size > 0)
+            return;
+        const meta = await this.request('/info', { type: 'meta' });
+        meta.universe.forEach((asset, index) => {
+            this.assetIndexMap.set(asset.name, index);
+        });
+    }
+    getAssetIndex(symbol) {
+        const index = this.assetIndexMap.get(symbol);
+        if (index === undefined) {
+            throw new Error(`Unknown asset: ${symbol}`);
+        }
+        return index;
+    }
+    signL1Action(action, nonce) {
+        // Create the message hash
+        const actionHash = keccak256(Buffer.from(JSON.stringify(action)));
+        const nonceBuffer = Buffer.alloc(8);
+        nonceBuffer.writeBigUInt64BE(BigInt(nonce));
+        const message = Buffer.concat([
+            actionHash,
+            nonceBuffer,
+        ]);
+        return signMessage(message, this.privateKey);
+    }
+    async getBalance() {
+        const data = await this.request('/info', {
+            type: 'clearinghouseState',
+            user: this.walletAddress,
+        });
+        const margin = data.marginSummary;
+        const total = safeFloat(margin.accountValue);
+        const used = safeFloat(margin.totalMarginUsed);
+        return {
+            exchange: 'hyperliquid',
+            asset: 'USDC',
+            available: total - used,
+            total,
+            unrealizedPnl: 0,
+            marginBalance: total,
+        };
+    }
+    async getPositions() {
+        const data = await this.request('/info', {
+            type: 'clearinghouseState',
+            user: this.walletAddress,
+        });
+        const allMids = await this.request('/info', { type: 'allMids' });
+        return data.assetPositions
+            .filter(ap => safeFloat(ap.position.szi) !== 0)
+            .map(ap => {
+            const p = ap.position;
+            const size = safeFloat(p.szi);
+            const entryPrice = safeFloat(p.entryPx);
+            const markPrice = safeFloat(allMids[p.coin] || p.entryPx);
+            const pnl = safeFloat(p.unrealizedPnl);
+            const positionValue = Math.abs(size) * entryPrice;
+            return {
+                exchange: 'hyperliquid',
+                symbol: p.coin,
+                side: (size > 0 ? 'LONG' : 'SHORT'),
+                size: Math.abs(size),
+                entryPrice,
+                markPrice,
+                liquidationPrice: safeFloat(p.liquidationPx || '0'),
+                leverage: parseInt(p.leverage.value, 10) || 1,
+                marginType: (p.leverage.type === 'cross' ? 'CROSS' : 'ISOLATED'),
+                unrealizedPnl: pnl,
+                unrealizedPnlPct: positionValue > 0 ? (pnl / positionValue) * 100 : 0,
+                margin: safeFloat(p.marginUsed),
+                timestamp: Date.now(),
+            };
+        });
+    }
+    async placeOrder(order) {
+        if (this.dryRun) {
+            logger_1.logger.info({ order }, '[DRY RUN] Would place Hyperliquid order');
+            return this.createDryRunOrder(order);
+        }
+        await this.ensureAssetIndex();
+        const assetIndex = this.getAssetIndex(order.symbol);
+        const nonce = Date.now();
+        const isStopOrder = order.type === 'STOP_MARKET' || order.type === 'TAKE_PROFIT_MARKET';
+        // Get current price for market orders
+        let limitPx = order.price;
+        if ((order.type === 'MARKET' || isStopOrder) && !limitPx) {
+            const allMids = await this.request('/info', { type: 'allMids' });
+            const midPrice = parseFloat(allMids[order.symbol] || '0');
+            if (midPrice <= 0) {
+                throw new Error(`Cannot determine price for ${order.symbol} on Hyperliquid. Check symbol name (use bare coin name like BTC, not BTCUSDT).`);
+            }
+            // Add/subtract 1% slippage for market orders
+            limitPx = order.side === 'BUY' ? midPrice * 1.01 : midPrice * 0.99;
+        }
+        let orderType;
+        if (isStopOrder && order.stopPrice) {
+            // Trigger order (stop loss or take profit)
+            orderType = {
+                trigger: {
+                    triggerPx: String(order.stopPrice),
+                    isMarket: true,
+                    tpsl: order.type === 'STOP_MARKET' ? 'sl' : 'tp',
+                },
+            };
+        }
+        else if (order.type === 'LIMIT') {
+            orderType = { limit: { tif: 'Gtc' } };
+        }
+        else {
+            orderType = { limit: { tif: 'Ioc' } }; // Market orders use IOC
+        }
+        const orderWire = {
+            a: assetIndex,
+            b: order.side === 'BUY',
+            p: String(limitPx),
+            s: String(order.size),
+            r: order.reduceOnly || isStopOrder,
+            t: orderType,
+        };
+        const action = {
+            type: 'order',
+            orders: [orderWire],
+            grouping: isStopOrder ? 'normalTpsl' : 'na',
+        };
+        const signature = this.signL1Action(action, nonce);
+        const result = await this.request('/exchange', {
+            action,
+            nonce,
+            signature: {
+                r: signature.r,
+                s: signature.s,
+                v: signature.v,
+            },
+            vaultAddress: null,
+        });
+        if (result.status !== 'ok') {
+            throw new Error(`Hyperliquid order failed: ${JSON.stringify(result)}`);
+        }
+        const status = result.response?.data?.statuses?.[0];
+        const orderId = status?.resting?.oid || status?.filled?.oid || nonce;
+        return {
+            id: String(orderId),
+            exchange: 'hyperliquid',
+            symbol: order.symbol,
+            side: order.side,
+            type: order.type,
+            size: order.size,
+            price: limitPx,
+            stopPrice: order.stopPrice,
+            leverage: order.leverage || 1,
+            reduceOnly: order.reduceOnly || isStopOrder,
+            status: status?.filled ? 'FILLED' : 'NEW',
+            filledSize: status?.filled ? order.size : 0,
+            avgFillPrice: limitPx || 0,
+            timestamp: Date.now(),
+        };
+    }
+    createDryRunOrder(order) {
+        const isMarket = order.type === 'MARKET';
+        return {
+            id: `dry-${Date.now()}-${(0, crypto_1.randomBytes)(4).toString('hex')}`,
+            exchange: 'hyperliquid',
+            symbol: order.symbol,
+            side: order.side,
+            type: order.type,
+            size: order.size,
+            price: order.price,
+            leverage: order.leverage || 1,
+            reduceOnly: order.reduceOnly || false,
+            status: isMarket ? 'FILLED' : 'NEW',
+            filledSize: isMarket ? order.size : 0,
+            avgFillPrice: isMarket ? (order.price || 0) : 0,
+            timestamp: Date.now(),
+        };
+    }
+    async cancelOrder(symbol, orderId) {
+        await this.ensureAssetIndex();
+        const assetIndex = this.getAssetIndex(symbol);
+        const nonce = Date.now();
+        const action = {
+            type: 'cancel',
+            cancels: [{ a: assetIndex, o: parseInt(orderId) }],
+        };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: {
+                r: signature.r,
+                s: signature.s,
+                v: signature.v,
+            },
+            vaultAddress: null,
+        });
+    }
+    async closePosition(symbol) {
+        const positions = await this.getPositions();
+        const position = positions.find(p => p.symbol === symbol);
+        if (!position)
+            return null;
+        return this.placeOrder({
+            symbol,
+            side: position.side === 'LONG' ? 'SELL' : 'BUY',
+            type: 'MARKET',
+            size: position.size,
+            reduceOnly: true,
+        });
+    }
+    async getMarkets() {
+        const [meta, allMids, fundingRates] = await Promise.all([
+            this.request('/info', { type: 'meta' }),
+            this.request('/info', { type: 'allMids' }),
+            this.request('/info', { type: 'metaAndAssetCtxs' }),
+        ]);
+        return meta.universe.map((m, idx) => ({
+            exchange: 'hyperliquid',
+            symbol: m.name,
+            baseAsset: m.name,
+            quoteAsset: 'USDC',
+            tickSize: 0.1,
+            lotSize: Math.pow(10, -m.szDecimals),
+            minNotional: 10,
+            maxLeverage: m.maxLeverage,
+            fundingRate: parseFloat(fundingRates[1]?.[idx]?.funding || '0') * 100,
+            markPrice: parseFloat(allMids[m.name] || '0'),
+            indexPrice: parseFloat(allMids[m.name] || '0'),
+            volume24h: parseFloat(fundingRates[1]?.[idx]?.dayNtlVlm || '0'),
+        }));
+    }
+    async getFundingRate(symbol) {
+        await this.ensureAssetIndex();
+        const assetIndex = this.getAssetIndex(symbol);
+        const data = await this.request('/info', { type: 'metaAndAssetCtxs' });
+        return {
+            rate: parseFloat(data[1]?.[assetIndex]?.funding || '0') * 100,
+            nextFundingTime: Date.now() + 3600000, // Hourly funding
+        };
+    }
+    async setLeverage(symbol, leverage, marginType = 'CROSS') {
+        await this.ensureAssetIndex();
+        const assetIndex = this.getAssetIndex(symbol);
+        const nonce = Date.now();
+        const action = {
+            type: 'updateLeverage',
+            asset: assetIndex,
+            isCross: marginType === 'CROSS',
+            leverage,
+        };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: {
+                r: signature.r,
+                s: signature.s,
+                v: signature.v,
+            },
+            vaultAddress: null,
+        });
+    }
+    async getOpenOrders(symbol) {
+        const data = await this.request('/info', {
+            type: 'openOrders',
+            user: this.walletAddress,
+        });
+        const filtered = symbol ? data.filter(o => o.coin === symbol) : data;
+        return filtered.map(o => ({
+            id: String(o.oid),
+            exchange: 'hyperliquid',
+            symbol: o.coin,
+            side: (o.side === 'B' ? 'BUY' : 'SELL'),
+            type: 'LIMIT',
+            size: parseFloat(o.sz),
+            price: parseFloat(o.limitPx),
+            leverage: 1,
+            reduceOnly: false,
+            status: 'NEW',
+            filledSize: 0,
+            avgFillPrice: parseFloat(o.limitPx),
+            timestamp: o.timestamp,
+        }));
+    }
+    // =========== ADDITIONAL COMPREHENSIVE METHODS ===========
+    async getAccountInfo() {
+        const [data, allMids] = await Promise.all([
+            this.request('/info', {
+                type: 'clearinghouseState',
+                user: this.walletAddress,
+            }),
+            this.request('/info', { type: 'allMids' }),
+        ]);
+        let totalUnrealized = 0;
+        const positions = data.assetPositions
+            .filter(ap => safeFloat(ap.position.szi) !== 0)
+            .map(ap => {
+            const p = ap.position;
+            const size = safeFloat(p.szi);
+            const unrealizedPnl = safeFloat(p.unrealizedPnl);
+            totalUnrealized += unrealizedPnl;
+            return {
+                exchange: 'hyperliquid',
+                symbol: p.coin,
+                side: (size > 0 ? 'LONG' : 'SHORT'),
+                size: Math.abs(size),
+                entryPrice: safeFloat(p.entryPx),
+                markPrice: safeFloat(allMids[p.coin] || p.entryPx),
+                liquidationPrice: safeFloat(p.liquidationPx || '0'),
+                leverage: parseInt(p.leverage.value, 10) || 1,
+                marginType: (p.leverage.type === 'cross' ? 'CROSS' : 'ISOLATED'),
+                unrealizedPnl,
+                unrealizedPnlPct: 0,
+                margin: 0,
+                timestamp: Date.now(),
+            };
+        });
+        const accountValue = safeFloat(data.marginSummary.accountValue);
+        const marginUsed = safeFloat(data.marginSummary.totalMarginUsed);
+        return {
+            exchange: 'hyperliquid',
+            totalWalletBalance: accountValue,
+            totalUnrealizedProfit: totalUnrealized,
+            totalMarginBalance: accountValue,
+            totalPositionInitialMargin: marginUsed,
+            totalOpenOrderInitialMargin: 0,
+            availableBalance: accountValue - marginUsed,
+            maxWithdrawAmount: safeFloat(data.marginSummary.totalRawUsd),
+            canTrade: true,
+            canDeposit: true,
+            canWithdraw: true,
+            positions,
+        };
+    }
+    async getTradeHistory(limit = 500) {
+        const data = await this.request('/info', {
+            type: 'userFills',
+            user: this.walletAddress,
+        });
+        return data.slice(0, limit).map(t => ({
+            id: String(t.tid),
+            exchange: 'hyperliquid',
+            symbol: t.coin,
+            orderId: String(t.oid),
+            side: (t.side === 'B' ? 'BUY' : 'SELL'),
+            price: parseFloat(t.px),
+            quantity: parseFloat(t.sz),
+            realizedPnl: parseFloat(t.closedPnl),
+            commission: parseFloat(t.fee),
+            commissionAsset: 'USDC',
+            timestamp: t.time,
+            isMaker: false,
+        }));
+    }
+    async getOrderHistory() {
+        const data = await this.request('/info', {
+            type: 'historicalOrders',
+            user: this.walletAddress,
+        });
+        return data.map(o => ({
+            id: String(o.order.oid),
+            exchange: 'hyperliquid',
+            symbol: o.order.coin,
+            side: (o.order.side === 'B' ? 'BUY' : 'SELL'),
+            type: 'LIMIT',
+            size: parseFloat(o.order.sz),
+            price: parseFloat(o.order.limitPx),
+            leverage: 1,
+            reduceOnly: o.order.reduceOnly,
+            status: (o.status === 'filled' ? 'FILLED' : o.status === 'canceled' ? 'CANCELED' : 'NEW'),
+            filledSize: o.status === 'filled' ? parseFloat(o.order.sz) : 0,
+            avgFillPrice: parseFloat(o.order.limitPx),
+            timestamp: o.statusTimestamp,
+        }));
+    }
+    async getOrderBook(symbol) {
+        const data = await this.request('/info', {
+            type: 'l2Book',
+            coin: symbol,
+        });
+        return {
+            exchange: 'hyperliquid',
+            symbol,
+            lastUpdateId: data.time,
+            bids: data.levels[0]?.map(l => [parseFloat(l.px), parseFloat(l.sz)]) || [],
+            asks: data.levels[1]?.map(l => [parseFloat(l.px), parseFloat(l.sz)]) || [],
+            timestamp: data.time,
+        };
+    }
+    async getKlines(symbol, interval, startTime, endTime) {
+        const data = await this.request('/info', {
+            type: 'candleSnapshot',
+            coin: symbol,
+            interval,
+            startTime: startTime || Date.now() - 86400000,
+            endTime: endTime || Date.now(),
+        });
+        return data.map(k => ({
+            openTime: k.t,
+            open: parseFloat(k.o),
+            high: parseFloat(k.h),
+            low: parseFloat(k.l),
+            close: parseFloat(k.c),
+            volume: parseFloat(k.v),
+            closeTime: k.t + 60000,
+            quoteVolume: 0,
+            trades: 0,
+            takerBuyVolume: 0,
+            takerBuyQuoteVolume: 0,
+        }));
+    }
+    async getUserFees() {
+        const data = await this.request('/info', {
+            type: 'userFees',
+            user: this.walletAddress,
+        });
+        return {
+            maker: parseFloat(data.feeSchedule.maker) * 100,
+            taker: parseFloat(data.feeSchedule.taker) * 100,
+        };
+    }
+    async getRateLimit() {
+        const data = await this.request('/info', {
+            type: 'userRateLimit',
+            user: this.walletAddress,
+        });
+        return {
+            used: data.nRequestsUsed,
+            limit: data.nRequestsCap,
+        };
+    }
+    async getOrderStatus(orderId) {
+        const data = await this.request('/info', {
+            type: 'orderStatus',
+            user: this.walletAddress,
+            oid: orderId,
+        });
+        return {
+            status: data.order?.status || 'unknown',
+            filled: parseFloat(data.order?.filledSz || '0'),
+        };
+    }
+    async cancelByClientOrderId(symbol, cloid) {
+        await this.ensureAssetIndex();
+        const assetIndex = this.getAssetIndex(symbol);
+        const nonce = Date.now();
+        const action = {
+            type: 'cancelByCloid',
+            cancels: [{ asset: assetIndex, cloid }],
+        };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    async modifyOrder(symbol, orderId, price, size, isBuy) {
+        await this.ensureAssetIndex();
+        const assetIndex = this.getAssetIndex(symbol);
+        const nonce = Date.now();
+        const action = {
+            type: 'batchModify',
+            modifies: [{
+                    oid: orderId,
+                    order: {
+                        a: assetIndex,
+                        b: isBuy,
+                        p: String(price),
+                        s: String(size),
+                        r: false,
+                        t: { limit: { tif: 'Gtc' } },
+                    },
+                }],
+        };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+        return {
+            id: String(orderId),
+            exchange: 'hyperliquid',
+            symbol,
+            side: isBuy ? 'BUY' : 'SELL',
+            type: 'LIMIT',
+            size,
+            price,
+            leverage: 1,
+            reduceOnly: false,
+            status: 'NEW',
+            filledSize: 0,
+            avgFillPrice: 0,
+            timestamp: Date.now(),
+        };
+    }
+    async updateIsolatedMargin(symbol, marginDelta) {
+        await this.ensureAssetIndex();
+        const assetIndex = this.getAssetIndex(symbol);
+        const nonce = Date.now();
+        const action = {
+            type: 'updateIsolatedMargin',
+            asset: assetIndex,
+            isBuy: true,
+            ntli: marginDelta,
+        };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    async transferUsd(amount, toPerp) {
+        const nonce = Date.now();
+        const action = {
+            type: 'usdTransfer',
+            amount: String(amount),
+            toPerp,
+        };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    async getSubAccounts() {
+        const data = await this.request('/info', {
+            type: 'subAccounts',
+            user: this.walletAddress,
+        });
+        return data;
+    }
+    async placeTwapOrder(symbol, isBuy, size, durationMinutes, randomize = true) {
+        await this.ensureAssetIndex();
+        const assetIndex = this.getAssetIndex(symbol);
+        const nonce = Date.now();
+        const action = {
+            type: 'twapOrder',
+            twap: {
+                a: assetIndex,
+                b: isBuy,
+                s: String(size),
+                r: false,
+                m: durationMinutes,
+                t: randomize,
+            },
+        };
+        const signature = this.signL1Action(action, nonce);
+        const result = await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+        return {
+            status: result.status,
+            twapId: result.response?.data?.running?.state?.twapId,
+        };
+    }
+    async cancelTwapOrder(symbol, twapId) {
+        await this.ensureAssetIndex();
+        const assetIndex = this.getAssetIndex(symbol);
+        const nonce = Date.now();
+        const action = {
+            type: 'twapCancel',
+            a: assetIndex,
+            t: twapId,
+        };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    async getMeta() {
+        return this.request('/info', { type: 'meta' });
+    }
+    // =========== ADDITIONAL HYPERLIQUID METHODS ===========
+    async scheduleCancel(time) {
+        const nonce = Date.now();
+        const action = { type: 'scheduleCancel', time };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    async sendUsd(destination, amount) {
+        const nonce = Date.now();
+        const action = { type: 'usdSend', destination, amount: String(amount) };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    async sendSpot(destination, token, amount) {
+        const nonce = Date.now();
+        const action = { type: 'spotSend', destination, token, amount: String(amount) };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    async withdraw(destination, amount) {
+        const nonce = Date.now();
+        const action = { type: 'withdraw3', destination, amount: String(amount) };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    async transferBetweenSpotAndPerp(amount, toPerp) {
+        const nonce = Date.now();
+        const action = { type: 'usdClassTransfer', amount: String(amount), toPerp };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    async vaultTransfer(vaultAddress, amount, isDeposit) {
+        const nonce = Date.now();
+        const action = { type: 'vaultTransfer', vaultAddress, usd: String(amount), isDeposit };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    async approveAgent(agentAddress, agentName) {
+        const nonce = Date.now();
+        const action = { type: 'approveAgent', agentAddress, agentName: agentName || null };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    async approveBuilderFee(builder, maxFeeRate) {
+        const nonce = Date.now();
+        const action = { type: 'approveBuilderFee', builder, maxFeeRate: String(maxFeeRate) };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    async setReferrer(code) {
+        const nonce = Date.now();
+        const action = { type: 'setReferrer', code };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    async stakeDeposit(amount) {
+        const nonce = Date.now();
+        const action = { type: 'cDeposit', amount: String(amount) };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    async stakeWithdraw(amount) {
+        const nonce = Date.now();
+        const action = { type: 'cWithdraw', amount: String(amount) };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    async delegateTokens(validator, amount, undelegate) {
+        const nonce = Date.now();
+        const action = { type: 'tokenDelegate', validator, amount: String(amount), undelegate };
+        const signature = this.signL1Action(action, nonce);
+        await this.request('/exchange', {
+            action,
+            nonce,
+            signature: { r: signature.r, s: signature.s, v: signature.v },
+            vaultAddress: null,
+        });
+    }
+    // Additional info queries
+    async getVaultDetails(vaultAddress) {
+        const data = await this.request('/info', { type: 'vaultDetails', vaultAddress });
+        return {
+            name: data.name,
+            vaultAddress: data.vaultAddress,
+            leader: data.leader,
+            tvl: 0,
+            totalPnl: 0,
+        };
+    }
+    async getUserVaultEquities() {
+        const data = await this.request('/info', {
+            type: 'userVaultEquities',
+            user: this.walletAddress,
+        });
+        return data.map(v => ({ vaultAddress: v.vaultAddress, equity: parseFloat(v.equity) }));
+    }
+    async getUserRole() {
+        return this.request('/info', { type: 'userRole', user: this.walletAddress });
+    }
+    async getPortfolio() {
+        const data = await this.request('/info', { type: 'portfolio', user: this.walletAddress });
+        return data.map(p => ({
+            name: p.name,
+            allTimePnl: parseFloat(p.allTimePnl),
+            dailyPnl: parseFloat(p.dailyPnl),
+            monthlyPnl: parseFloat(p.monthlyPnl),
+        }));
+    }
+    async getReferralInfo() {
+        const data = await this.request('/info', { type: 'referral', user: this.walletAddress });
+        return {
+            referredBy: data.referredBy,
+            cumVlm: parseFloat(data.cumVlm),
+            unclaimedRewards: parseFloat(data.unclaimedRewards),
+            claimedRewards: parseFloat(data.claimedRewards),
+        };
+    }
+    async getStakingDelegations() {
+        const data = await this.request('/info', { type: 'delegations', user: this.walletAddress });
+        return data.map(d => ({
+            validator: d.validator,
+            amount: parseFloat(d.amount),
+            lockedUntil: d.lockedUntil,
+        }));
+    }
+    async getStakingSummary() {
+        const data = await this.request('/info', { type: 'delegatorSummary', user: this.walletAddress });
+        return {
+            delegated: parseFloat(data.delegated),
+            undelegating: parseFloat(data.undelegating),
+            claimable: parseFloat(data.claimable),
+            totalRewards: parseFloat(data.totalRewards),
+        };
+    }
+    async getStakingRewards(limit = 100) {
+        const data = await this.request('/info', { type: 'delegatorRewards', user: this.walletAddress });
+        return data.slice(0, limit).map(r => ({
+            validator: r.validator,
+            amount: parseFloat(r.amount),
+            timestamp: r.time,
+        }));
+    }
+    async getBorrowLendState() {
+        const data = await this.request('/info', { type: 'borrowLendUserState', user: this.walletAddress });
+        return {
+            borrowed: parseFloat(data.borrowed),
+            lent: parseFloat(data.lent),
+            borrowApy: parseFloat(data.borrowApy),
+            lendApy: parseFloat(data.lendApy),
+        };
+    }
+    async getAllBorrowLendReserves() {
+        const data = await this.request('/info', { type: 'allBorrowLendReserveStates' });
+        return data.map(r => ({
+            coin: r.coin,
+            totalBorrowed: parseFloat(r.totalBorrowed),
+            totalLent: parseFloat(r.totalLent),
+            borrowApy: parseFloat(r.borrowApy),
+            lendApy: parseFloat(r.lendApy),
+        }));
+    }
+    async getFrontendOpenOrders() {
+        const data = await this.request('/info', {
+            type: 'frontendOpenOrders',
+            user: this.walletAddress,
+        });
+        return data.map(o => ({
+            coin: o.coin,
+            oid: o.oid,
+            side: o.side,
+            limitPx: parseFloat(o.limitPx),
+            sz: parseFloat(o.sz),
+            timestamp: o.timestamp,
+            triggerCondition: o.triggerCondition,
+            isTrigger: o.isTrigger,
+            reduceOnly: o.reduceOnly,
+        }));
+    }
+    async getTwapSliceFills() {
+        const data = await this.request('/info', {
+            type: 'userTwapSliceFills',
+            user: this.walletAddress,
+        });
+        return data.map(f => ({
+            coin: f.coin,
+            px: parseFloat(f.px),
+            sz: parseFloat(f.sz),
+            side: f.side,
+            time: f.time,
+            fee: parseFloat(f.fee),
+            twapId: f.twapId,
+        }));
+    }
+    async getMaxBuilderFee(builder) {
+        const data = await this.request('/info', {
+            type: 'maxBuilderFee',
+            user: this.walletAddress,
+            builder,
+        });
+        return { maxFeeRate: parseFloat(data.maxFeeRate) };
+    }
+    async getSpotMeta() {
+        return this.request('/info', { type: 'spotMeta' });
+    }
+    async getSpotClearinghouseState() {
+        const data = await this.request('/info', {
+            type: 'spotClearinghouseState',
+            user: this.walletAddress,
+        });
+        return {
+            balances: data.balances.map(b => ({
+                coin: b.coin,
+                hold: parseFloat(b.hold),
+                total: parseFloat(b.total),
+            })),
+        };
+    }
+}
+exports.HyperliquidClient = HyperliquidClient;
+// =============================================================================
+// MEXC FUTURES CLIENT (No KYC required for small amounts)
+// =============================================================================
+class MexcFuturesClient {
+    apiKey;
+    apiSecret;
+    baseUrl = 'https://contract.mexc.com';
+    dryRun;
+    _marginType = 'ISOLATED';
+    constructor(credentials, dryRun = false) {
+        this.apiKey = credentials.apiKey;
+        this.apiSecret = credentials.apiSecret;
+        this.dryRun = dryRun;
+    }
+    setMarginTypePreference(marginType) {
+        this._marginType = marginType;
+    }
+    sign(timestamp, params) {
+        const payload = `${this.apiKey}${timestamp}${params}`;
+        return (0, crypto_1.createHmac)('sha256', this.apiSecret).update(payload).digest('hex');
+    }
+    async request(method, endpoint, params = {}, signed = false) {
+        const timestamp = String(Date.now());
+        const url = new URL(endpoint, this.baseUrl);
+        let queryString = '';
+        let body = '';
+        if (method === 'GET') {
+            queryString = Object.entries(params)
+                .filter(([, v]) => v !== undefined && typeof v !== 'object')
+                .map(([k, v]) => `${k}=${encodeURIComponent(String(v))}`)
+                .join('&');
+            if (queryString)
+                url.search = queryString;
+        }
+        else {
+            body = JSON.stringify(params);
+        }
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (signed) {
+            const signData = method === 'GET' ? queryString : body;
+            headers['ApiKey'] = this.apiKey;
+            headers['Request-Time'] = timestamp;
+            headers['Signature'] = this.sign(timestamp, signData);
+        }
+        const response = await fetchWithRetry(url.toString(), {
+            method,
+            headers,
+            body: method !== 'GET' ? body : undefined,
+            signal: AbortSignal.timeout(30_000),
+        });
+        const data = await response.json();
+        if (!data.success || data.code !== 0) {
+            throw new Error(`MEXC error: ${data.message || data.code}`);
+        }
+        return data.data;
+    }
+    async getBalance() {
+        const data = await this.request('GET', '/api/v1/private/account/assets', {}, true);
+        const usdt = data.find(b => b.currency === 'USDT') || {
+            availableBalance: '0',
+            equity: '0',
+            unrealized: '0',
+        };
+        return {
+            exchange: 'mexc',
+            asset: 'USDT',
+            available: safeFloat(usdt.availableBalance),
+            total: safeFloat(usdt.equity),
+            unrealizedPnl: safeFloat(usdt.unrealized),
+            marginBalance: safeFloat(usdt.equity),
+        };
+    }
+    async getPositions() {
+        const data = await this.request('GET', '/api/v1/private/position/open_positions', {}, true);
+        // Get mark prices
+        const tickers = await this.request('GET', '/api/v1/contract/ticker');
+        const priceMap = new Map(tickers.map(t => [t.symbol, safeFloat(t.lastPrice)]));
+        return data.map(p => {
+            const size = safeFloat(p.holdVol);
+            const entryPrice = safeFloat(p.openAvgPrice);
+            const markPrice = priceMap.get(p.symbol) || entryPrice;
+            const pnl = safeFloat(p.unrealised);
+            const positionValue = size * entryPrice;
+            return {
+                exchange: 'mexc',
+                symbol: p.symbol,
+                side: (p.positionType === 1 ? 'LONG' : 'SHORT'),
+                size,
+                entryPrice,
+                markPrice,
+                liquidationPrice: safeFloat(p.liquidatePrice),
+                leverage: p.leverage || 1,
+                marginType: 'ISOLATED', // MEXC uses isolated by default
+                unrealizedPnl: pnl,
+                unrealizedPnlPct: positionValue > 0 ? (pnl / positionValue) * 100 : 0,
+                margin: safeFloat(p.margin || p.im),
+                timestamp: Date.now(),
+            };
+        });
+    }
+    async setLeverage(symbol, leverage) {
+        const openType = this._marginType === 'CROSS' ? 2 : 1;
+        await this.request('POST', '/api/v1/private/position/change_leverage', {
+            symbol,
+            leverage,
+            openType,
+            positionType: 1, // long
+        }, true);
+        await this.request('POST', '/api/v1/private/position/change_leverage', {
+            symbol,
+            leverage,
+            openType,
+            positionType: 2, // short
+        }, true);
+    }
+    async placeOrder(order) {
+        if (this.dryRun) {
+            logger_1.logger.info({ order }, '[DRY RUN] Would place MEXC futures order');
+            return this.createDryRunOrder(order);
+        }
+        if (order.leverage) {
+            await this.setLeverage(order.symbol, order.leverage);
+        }
+        const isStopOrder = order.type === 'STOP_MARKET' || order.type === 'TAKE_PROFIT_MARKET';
+        // MEXC uses vol (contracts) not size
+        const params = {
+            symbol: order.symbol,
+            side: order.side === 'BUY' ? 1 : 2, // 1=open long/close short, 2=close long/open short
+            type: (order.type === 'MARKET' || isStopOrder) ? 5 : 1, // 1=limit, 5=market
+            vol: order.size,
+            openType: this._marginType === 'CROSS' ? 2 : 1, // 1=isolated, 2=cross
+        };
+        // Determine if opening or closing
+        const isOpening = !order.reduceOnly && !isStopOrder;
+        if (order.side === 'BUY') {
+            params.side = isOpening ? 1 : 4; // 1=open long, 4=close short
+        }
+        else {
+            params.side = isOpening ? 3 : 2; // 3=open short, 2=close long
+        }
+        if (order.price && order.type === 'LIMIT') {
+            params.price = order.price;
+        }
+        // Set trigger price for stop orders
+        if (isStopOrder && order.stopPrice) {
+            params.triggerPrice = order.stopPrice;
+            params.triggerType = 1; // trigger by mark price
+        }
+        const result = await this.request('POST', '/api/v1/private/order/submit', params, true);
+        const mainOrder = {
+            id: result.orderId,
+            exchange: 'mexc',
+            symbol: order.symbol,
+            side: order.side,
+            type: order.type,
+            size: order.size,
+            price: order.price,
+            leverage: order.leverage || 1,
+            reduceOnly: order.reduceOnly || false,
+            status: 'NEW',
+            filledSize: 0,
+            avgFillPrice: 0,
+            timestamp: Date.now(),
+        };
+        // Place TP/SL if specified — don't let failures lose the main order
+        try {
+            if (order.takeProfit) {
+                await this.request('POST', '/api/v1/private/order/submit_tp_sl', {
+                    symbol: order.symbol,
+                    triggerPrice: order.takeProfit,
+                    triggerType: 1, // take profit
+                    executePriceType: 1, // market
+                }, true);
+            }
+        }
+        catch (err) {
+            logger_1.logger.error({ err, symbol: order.symbol, takeProfit: order.takeProfit }, 'MEXC: Failed to place take-profit order (main order succeeded)');
+        }
+        try {
+            if (order.stopLoss) {
+                await this.request('POST', '/api/v1/private/order/submit_tp_sl', {
+                    symbol: order.symbol,
+                    triggerPrice: order.stopLoss,
+                    triggerType: 2, // stop loss
+                    executePriceType: 1, // market
+                }, true);
+            }
+        }
+        catch (err) {
+            logger_1.logger.error({ err, symbol: order.symbol, stopLoss: order.stopLoss }, 'MEXC: Failed to place stop-loss order (main order succeeded)');
+        }
+        return mainOrder;
+    }
+    createDryRunOrder(order) {
+        const isMarket = order.type === 'MARKET';
+        return {
+            id: `dry-${Date.now()}-${(0, crypto_1.randomBytes)(4).toString('hex')}`,
+            exchange: 'mexc',
+            symbol: order.symbol,
+            side: order.side,
+            type: order.type,
+            size: order.size,
+            price: order.price,
+            leverage: order.leverage || 1,
+            reduceOnly: order.reduceOnly || false,
+            status: isMarket ? 'FILLED' : 'NEW',
+            filledSize: isMarket ? order.size : 0,
+            avgFillPrice: isMarket ? (order.price || 0) : 0,
+            timestamp: Date.now(),
+        };
+    }
+    async cancelOrder(symbol, orderId) {
+        await this.request('POST', '/api/v1/private/order/cancel', {
+            symbol,
+            orderId,
+        }, true);
+    }
+    async closePosition(symbol) {
+        const positions = await this.getPositions();
+        const position = positions.find(p => p.symbol === symbol);
+        if (!position)
+            return null;
+        return this.placeOrder({
+            symbol,
+            side: position.side === 'LONG' ? 'SELL' : 'BUY',
+            type: 'MARKET',
+            size: position.size,
+            reduceOnly: true,
+        });
+    }
+    async getMarkets() {
+        const [contracts, tickers] = await Promise.all([
+            this.request('GET', '/api/v1/contract/detail'),
+            this.request('GET', '/api/v1/contract/ticker'),
+        ]);
+        const tickerMap = new Map(tickers.map(t => [t.symbol, t]));
+        return contracts
+            .filter(c => c.quoteCoin === 'USDT')
+            .map(c => {
+            const ticker = tickerMap.get(c.symbol);
+            return {
+                exchange: 'mexc',
+                symbol: c.symbol,
+                baseAsset: c.baseCoin,
+                quoteAsset: c.quoteCoin,
+                tickSize: parseFloat(c.priceUnit),
+                lotSize: parseFloat(c.volUnit),
+                minNotional: parseFloat(c.minVol),
+                maxLeverage: c.maxLeverage,
+                fundingRate: parseFloat(ticker?.fundingRate || '0') * 100,
+                markPrice: parseFloat(ticker?.fairPrice || ticker?.lastPrice || '0'),
+                indexPrice: parseFloat(ticker?.indexPrice || '0'),
+                volume24h: parseFloat(ticker?.volume24 || '0'),
+            };
+        });
+    }
+    async getFundingRate(symbol) {
+        const data = await this.request('GET', '/api/v1/contract/funding_rate', { symbol });
+        return {
+            rate: parseFloat(data.fundingRate) * 100,
+            nextFundingTime: data.nextSettleTime,
+        };
+    }
+    async getOpenOrders(symbol) {
+        const params = {};
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/api/v1/private/order/open_orders', params, true);
+        return data.map(o => ({
+            id: o.orderId,
+            exchange: 'mexc',
+            symbol: o.symbol,
+            side: ((o.side === 1 || o.side === 4) ? 'BUY' : 'SELL'),
+            type: (o.type === 5 ? 'MARKET' : 'LIMIT'),
+            size: parseFloat(o.vol),
+            price: parseFloat(o.price),
+            leverage: 1,
+            reduceOnly: o.side === 2 || o.side === 4,
+            status: this.mapMexcStatus(o.state),
+            filledSize: parseFloat(o.dealVol),
+            avgFillPrice: parseFloat(o.dealAvgPrice),
+            timestamp: o.createTime,
+        }));
+    }
+    mapMexcStatus(state) {
+        // 1=pending, 2=filled, 3=partially filled, 4=canceled, 5=partially canceled
+        const statusMap = {
+            1: 'NEW',
+            2: 'FILLED',
+            3: 'PARTIALLY_FILLED',
+            4: 'CANCELED',
+            5: 'PARTIALLY_FILLED',
+        };
+        return statusMap[state] || 'NEW';
+    }
+    // =========== ADDITIONAL COMPREHENSIVE METHODS ===========
+    async getAccountInfo() {
+        const assets = await this.getBalance();
+        const positions = await this.getPositions();
+        return {
+            exchange: 'mexc',
+            totalWalletBalance: assets.total,
+            totalUnrealizedProfit: assets.unrealizedPnl,
+            totalMarginBalance: assets.marginBalance,
+            totalPositionInitialMargin: 0,
+            totalOpenOrderInitialMargin: 0,
+            availableBalance: assets.available,
+            maxWithdrawAmount: assets.available,
+            canTrade: true,
+            canDeposit: true,
+            canWithdraw: true,
+            positions,
+        };
+    }
+    async getTradeHistory(symbol, limit = 100) {
+        const params = { page_num: 1, page_size: limit };
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/api/v1/private/order/list/order_deals', params, true);
+        return data.map(t => ({
+            id: t.id,
+            exchange: 'mexc',
+            symbol: t.symbol,
+            orderId: t.orderId,
+            side: ((t.side === 1 || t.side === 4) ? 'BUY' : 'SELL'),
+            price: parseFloat(t.price),
+            quantity: parseFloat(t.vol),
+            realizedPnl: parseFloat(t.profit),
+            commission: parseFloat(t.fee),
+            commissionAsset: t.feeCurrency,
+            timestamp: t.timestamp,
+            isMaker: t.maker,
+        }));
+    }
+    async getOrderHistory(symbol, limit = 100) {
+        const params = { page_num: 1, page_size: limit };
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/api/v1/private/order/list/history_orders', params, true);
+        return data.map(o => ({
+            id: o.orderId,
+            exchange: 'mexc',
+            symbol: o.symbol,
+            side: ((o.side === 1 || o.side === 4) ? 'BUY' : 'SELL'),
+            type: (o.type === 5 ? 'MARKET' : 'LIMIT'),
+            size: parseFloat(o.vol),
+            price: parseFloat(o.price),
+            leverage: 1,
+            reduceOnly: o.side === 2 || o.side === 4,
+            status: this.mapMexcStatus(o.state),
+            filledSize: parseFloat(o.dealVol),
+            avgFillPrice: parseFloat(o.dealAvgPrice),
+            timestamp: o.createTime,
+        }));
+    }
+    async getKlines(symbol, interval, limit = 100) {
+        const data = await this.request('GET', `/api/v1/contract/kline/${symbol}`, {
+            interval,
+            limit,
+        });
+        return data.time.map((t, i) => ({
+            openTime: t * 1000,
+            open: data.open[i],
+            high: data.high[i],
+            low: data.low[i],
+            close: data.close[i],
+            volume: data.vol[i],
+            closeTime: (t + 60) * 1000,
+            quoteVolume: 0,
+            trades: 0,
+            takerBuyVolume: 0,
+            takerBuyQuoteVolume: 0,
+        }));
+    }
+    async getOrderBook(symbol, limit = 100) {
+        const data = await this.request('GET', `/api/v1/contract/depth/${symbol}`, { limit });
+        return {
+            exchange: 'mexc',
+            symbol,
+            lastUpdateId: data.version,
+            bids: data.bids.map(([price, qty]) => [price, qty]),
+            asks: data.asks.map(([price, qty]) => [price, qty]),
+            timestamp: data.timestamp,
+        };
+    }
+    async getPositionHistory(symbol, limit = 100) {
+        const params = { page_num: 1, page_size: limit };
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/api/v1/private/position/list/history_positions', params, true);
+        return data.map(p => ({
+            symbol: p.symbol,
+            side: (p.positionType === 1 ? 'LONG' : 'SHORT'),
+            entryPrice: parseFloat(p.openAvgPrice),
+            closePrice: parseFloat(p.closeAvgPrice),
+            size: parseFloat(p.holdVol),
+            realizedPnl: parseFloat(p.realised),
+            openTime: p.openTime,
+            closeTime: p.closeTime,
+        }));
+    }
+    async getFundingHistory(symbol, limit = 100) {
+        const params = { page_num: 1, page_size: limit };
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/api/v1/private/position/funding_records', params, true);
+        return data.map(f => ({
+            symbol: f.symbol,
+            fundingRate: parseFloat(f.fundingRate) * 100,
+            fundingTime: f.settleTime,
+        }));
+    }
+    async modifyPositionMargin(symbol, amount, positionType) {
+        await this.request('POST', '/api/v1/private/position/change_margin', {
+            symbol,
+            amount,
+            type: amount > 0 ? 'ADD' : 'SUB',
+            positionType, // 1=long, 2=short
+        }, true);
+    }
+    async getPositionMode() {
+        const data = await this.request('GET', '/api/v1/private/position/position_mode', {}, true);
+        return data.positionMode === 1 ? 'hedge' : 'one_way';
+    }
+    async setPositionMode(hedgeMode) {
+        await this.request('POST', '/api/v1/private/position/change_position_mode', {
+            positionMode: hedgeMode ? 1 : 2,
+        }, true);
+    }
+    async placeBatchOrders(orders) {
+        if (this.dryRun) {
+            return orders.map(o => this.createDryRunOrder(o));
+        }
+        const batchOrders = orders.map(order => ({
+            symbol: order.symbol,
+            side: order.side === 'BUY' ? (order.reduceOnly ? 4 : 1) : (order.reduceOnly ? 2 : 3),
+            type: order.type === 'MARKET' ? 5 : 1,
+            vol: order.size,
+            price: order.price,
+            openType: this._marginType === 'CROSS' ? 2 : 1,
+        }));
+        const result = await this.request('POST', '/api/v1/private/order/submit_batch', {
+            orders: batchOrders,
+        }, true);
+        return result.map((r, i) => ({
+            id: r.orderId,
+            exchange: 'mexc',
+            symbol: orders[i].symbol,
+            side: orders[i].side,
+            type: orders[i].type,
+            size: orders[i].size,
+            price: orders[i].price,
+            leverage: orders[i].leverage || 1,
+            reduceOnly: orders[i].reduceOnly || false,
+            status: 'NEW',
+            filledSize: 0,
+            avgFillPrice: 0,
+            timestamp: Date.now(),
+        }));
+    }
+    async cancelAllOrders(symbol) {
+        await this.request('POST', '/api/v1/private/order/cancel_all', { symbol }, true);
+    }
+    async getTickerPrice(symbol) {
+        const data = await this.request('GET', '/api/v1/contract/ticker');
+        const filtered = symbol ? data.filter(t => t.symbol === symbol) : data;
+        return filtered.map(t => ({
+            symbol: t.symbol,
+            price: t.lastPrice,
+            timestamp: t.timestamp,
+        }));
+    }
+    async getRecentTrades(symbol, limit = 100) {
+        const data = await this.request('GET', `/api/v1/contract/deals/${symbol}`, { limit });
+        return data.map(t => ({
+            price: t.p,
+            size: t.v,
+            side: t.T === 1 ? 'buy' : 'sell',
+            timestamp: t.t,
+        }));
+    }
+    async getRiskLimits() {
+        const data = await this.request('GET', '/api/v1/private/account/risk_limit', {}, true);
+        return data.map(r => ({
+            symbol: r.symbol,
+            maxLeverage: r.maxLeverage,
+            maintenanceMarginRate: parseFloat(r.maintainMargin),
+            riskLimitValue: parseFloat(r.riskLimitValue),
+        }));
+    }
+    async getTieredFeeRate() {
+        const data = await this.request('GET', '/api/v1/private/account/tiered_fee_rate', {}, true);
+        return {
+            makerFee: parseFloat(data.makerFeeRate) * 100,
+            takerFee: parseFloat(data.takerFeeRate) * 100,
+            level: data.level,
+        };
+    }
+    async placeTriggerOrder(symbol, side, size, triggerPrice, triggerType, price) {
+        const result = await this.request('POST', '/api/v1/private/planorder/place', {
+            symbol,
+            side: side === 'BUY' ? 1 : 3,
+            vol: size,
+            triggerPrice,
+            triggerType: triggerType === 'ge' ? 1 : 2,
+            executePriceType: price ? 1 : 2, // 1=limit, 2=market
+            price: price || 0,
+            openType: this._marginType === 'CROSS' ? 2 : 1,
+        }, true);
+        return result.orderId;
+    }
+    async cancelTriggerOrder(symbol, orderId) {
+        await this.request('POST', '/api/v1/private/planorder/cancel', {
+            symbol,
+            orderId,
+        }, true);
+    }
+    async cancelAllTriggerOrders(symbol) {
+        await this.request('POST', '/api/v1/private/planorder/cancel_all', { symbol }, true);
+    }
+    async getTriggerOrders(symbol) {
+        const params = { states: 'NOT_TRIGGERED', page_num: 1, page_size: 100 };
+        if (symbol)
+            params.symbol = symbol;
+        const data = await this.request('GET', '/api/v1/private/planorder/list/orders', params, true);
+        return data.map(o => ({
+            orderId: o.id,
+            symbol: o.symbol,
+            side: ((o.side === 1 || o.side === 4) ? 'BUY' : 'SELL'),
+            size: parseFloat(o.vol),
+            triggerPrice: parseFloat(o.triggerPrice),
+            status: o.state,
+        }));
+    }
+    async getServerTime() {
+        const data = await this.request('GET', '/api/v1/contract/ping');
+        return data.serverTime;
+    }
+}
+exports.MexcFuturesClient = MexcFuturesClient;
+// =============================================================================
+// FUTURES DATABASE MANAGER
+// =============================================================================
+class FuturesDatabase {
+    pool = null;
+    initialized = false;
+    async connect(config) {
+        const connectionString = config.connectionString ||
+            `postgres://${config.user}:${config.password}@${config.host || 'localhost'}:${config.port || 5432}/${config.database}`;
+        this.pool = new pg_1.Pool({ connectionString });
+        // Test connection
+        const client = await this.pool.connect();
+        try {
+            await client.query('SELECT 1');
+            logger_1.logger.info('Connected to futures database');
+        }
+        finally {
+            client.release();
+        }
+    }
+    async initialize() {
+        if (this.initialized || !this.pool)
+            return;
+        const client = await this.pool.connect();
+        try {
+            // Create futures_trades table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS futures_trades (
+          id SERIAL PRIMARY KEY,
+          exchange VARCHAR(20) NOT NULL,
+          symbol VARCHAR(30) NOT NULL,
+          side VARCHAR(10) NOT NULL,
+          entry_price DECIMAL(20, 8) NOT NULL,
+          exit_price DECIMAL(20, 8),
+          size DECIMAL(20, 8) NOT NULL,
+          leverage INTEGER NOT NULL,
+          entry_time TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+          exit_time TIMESTAMPTZ,
+          pnl DECIMAL(20, 8),
+          pnl_pct DECIMAL(10, 4),
+          fees DECIMAL(20, 8),
+          strategy VARCHAR(100),
+          strategy_variant VARCHAR(100),
+          variables JSONB DEFAULT '{}',
+          tags TEXT[],
+          notes TEXT,
+          created_at TIMESTAMPTZ DEFAULT NOW()
+        )
+      `);
+            // Create futures_strategies table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS futures_strategies (
+          id SERIAL PRIMARY KEY,
+          name VARCHAR(100) UNIQUE NOT NULL,
+          version VARCHAR(20) NOT NULL,
+          description TEXT,
+          variables JSONB NOT NULL DEFAULT '[]',
+          enabled BOOLEAN DEFAULT true,
+          created_at TIMESTAMPTZ DEFAULT NOW(),
+          updated_at TIMESTAMPTZ DEFAULT NOW()
+        )
+      `);
+            // Create futures_strategy_variants table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS futures_strategy_variants (
+          id SERIAL PRIMARY KEY,
+          strategy_name VARCHAR(100) NOT NULL,
+          variant_name VARCHAR(100) NOT NULL,
+          variables JSONB NOT NULL DEFAULT '{}',
+          enabled BOOLEAN DEFAULT true,
+          created_at TIMESTAMPTZ DEFAULT NOW(),
+          UNIQUE(strategy_name, variant_name)
+        )
+      `);
+            // Create indexes for performance
+            await client.query(`
+        CREATE INDEX IF NOT EXISTS idx_futures_trades_strategy ON futures_trades(strategy);
+        CREATE INDEX IF NOT EXISTS idx_futures_trades_variant ON futures_trades(strategy_variant);
+        CREATE INDEX IF NOT EXISTS idx_futures_trades_exchange ON futures_trades(exchange);
+        CREATE INDEX IF NOT EXISTS idx_futures_trades_symbol ON futures_trades(symbol);
+        CREATE INDEX IF NOT EXISTS idx_futures_trades_entry_time ON futures_trades(entry_time);
+      `);
+            this.initialized = true;
+            logger_1.logger.info('Futures database initialized');
+        }
+        finally {
+            client.release();
+        }
+    }
+    async recordTrade(trade) {
+        if (!this.pool)
+            throw new Error('Database not connected');
+        const result = await this.pool.query(`INSERT INTO futures_trades
+       (exchange, symbol, side, entry_price, exit_price, size, leverage, entry_time, exit_time, pnl, pnl_pct, fees, strategy, strategy_variant, variables, tags, notes)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17)
+       RETURNING id`, [
+            trade.exchange,
+            trade.symbol,
+            trade.side,
+            trade.entryPrice,
+            trade.exitPrice || null,
+            trade.size,
+            trade.leverage,
+            trade.entryTime,
+            trade.exitTime || null,
+            trade.pnl || null,
+            trade.pnlPct || null,
+            trade.fees || null,
+            trade.strategy || null,
+            trade.strategyVariant || null,
+            JSON.stringify(trade.variables || {}),
+            trade.tags || null,
+            trade.notes || null,
+        ]);
+        return result.rows[0].id;
+    }
+    async updateTrade(id, updates) {
+        if (!this.pool)
+            throw new Error('Database not connected');
+        const setClauses = [];
+        const values = [];
+        let paramIndex = 1;
+        if (updates.exitPrice !== undefined) {
+            setClauses.push(`exit_price = $${paramIndex++}`);
+            values.push(updates.exitPrice);
+        }
+        if (updates.exitTime !== undefined) {
+            setClauses.push(`exit_time = $${paramIndex++}`);
+            values.push(updates.exitTime);
+        }
+        if (updates.pnl !== undefined) {
+            setClauses.push(`pnl = $${paramIndex++}`);
+            values.push(updates.pnl);
+        }
+        if (updates.pnlPct !== undefined) {
+            setClauses.push(`pnl_pct = $${paramIndex++}`);
+            values.push(updates.pnlPct);
+        }
+        if (updates.fees !== undefined) {
+            setClauses.push(`fees = $${paramIndex++}`);
+            values.push(updates.fees);
+        }
+        if (updates.notes !== undefined) {
+            setClauses.push(`notes = $${paramIndex++}`);
+            values.push(updates.notes);
+        }
+        if (setClauses.length === 0)
+            return;
+        values.push(id);
+        await this.pool.query(`UPDATE futures_trades SET ${setClauses.join(', ')} WHERE id = $${paramIndex}`, values);
+    }
+    async getTrades(filters) {
+        if (!this.pool)
+            throw new Error('Database not connected');
+        let query = 'SELECT * FROM futures_trades WHERE 1=1';
+        const values = [];
+        let paramIndex = 1;
+        if (filters?.strategy) {
+            query += ` AND strategy = $${paramIndex++}`;
+            values.push(filters.strategy);
+        }
+        if (filters?.strategyVariant) {
+            query += ` AND strategy_variant = $${paramIndex++}`;
+            values.push(filters.strategyVariant);
+        }
+        if (filters?.exchange) {
+            query += ` AND exchange = $${paramIndex++}`;
+            values.push(filters.exchange);
+        }
+        if (filters?.symbol) {
+            query += ` AND symbol = $${paramIndex++}`;
+            values.push(filters.symbol);
+        }
+        if (filters?.startDate) {
+            query += ` AND entry_time >= $${paramIndex++}`;
+            values.push(filters.startDate);
+        }
+        if (filters?.endDate) {
+            query += ` AND entry_time <= $${paramIndex++}`;
+            values.push(filters.endDate);
+        }
+        query += ' ORDER BY entry_time DESC';
+        if (filters?.limit) {
+            query += ` LIMIT $${paramIndex++}`;
+            values.push(filters.limit);
+        }
+        const result = await this.pool.query(query, values);
+        return result.rows.map(row => ({
+            id: row.id,
+            exchange: row.exchange,
+            symbol: row.symbol,
+            side: row.side,
+            entryPrice: parseFloat(row.entry_price),
+            exitPrice: row.exit_price ? parseFloat(row.exit_price) : undefined,
+            size: parseFloat(row.size),
+            leverage: row.leverage,
+            entryTime: row.entry_time,
+            exitTime: row.exit_time || undefined,
+            pnl: row.pnl ? parseFloat(row.pnl) : undefined,
+            pnlPct: row.pnl_pct ? parseFloat(row.pnl_pct) : undefined,
+            fees: row.fees ? parseFloat(row.fees) : undefined,
+            strategy: row.strategy || undefined,
+            strategyVariant: row.strategy_variant || undefined,
+            variables: row.variables,
+            tags: row.tags || undefined,
+            notes: row.notes || undefined,
+        }));
+    }
+    async getStrategyPerformance(strategyName, variantName) {
+        if (!this.pool)
+            throw new Error('Database not connected');
+        let query = `
+      SELECT
+        COUNT(*) as total_trades,
+        COUNT(CASE WHEN pnl > 0 THEN 1 END) as winning_trades,
+        COUNT(CASE WHEN pnl <= 0 THEN 1 END) as losing_trades,
+        COALESCE(SUM(pnl), 0) as total_pnl,
+        COALESCE(AVG(pnl), 0) as avg_pnl,
+        COALESCE(AVG(pnl_pct), 0) as avg_pnl_pct,
+        COALESCE(AVG(EXTRACT(EPOCH FROM (exit_time - entry_time))), 0) as avg_holding_seconds
+      FROM futures_trades
+      WHERE strategy = $1 AND exit_time IS NOT NULL
+    `;
+        const values = [strategyName];
+        if (variantName) {
+            query += ' AND strategy_variant = $2';
+            values.push(variantName);
+        }
+        const result = await this.pool.query(query, values);
+        const row = result.rows[0];
+        const totalTrades = parseInt(row.total_trades);
+        const winningTrades = parseInt(row.winning_trades);
+        const losingTrades = parseInt(row.losing_trades);
+        return {
+            strategyName,
+            variantName,
+            totalTrades,
+            winningTrades,
+            losingTrades,
+            winRate: totalTrades > 0 ? (winningTrades / totalTrades) * 100 : 0,
+            totalPnl: parseFloat(row.total_pnl),
+            avgPnl: parseFloat(row.avg_pnl),
+            avgPnlPct: parseFloat(row.avg_pnl_pct),
+            maxDrawdown: 0, // Calculated separately if needed
+            avgHoldingTime: parseFloat(row.avg_holding_seconds) / 60, // Convert to minutes
+        };
+    }
+    async compareVariants(strategyName) {
+        if (!this.pool)
+            throw new Error('Database not connected');
+        const result = await this.pool.query(`SELECT DISTINCT strategy_variant FROM futures_trades WHERE strategy = $1`, [strategyName]);
+        const performances = await Promise.all(result.rows.map(row => this.getStrategyPerformance(strategyName, row.strategy_variant)));
+        return performances.sort((a, b) => b.winRate - a.winRate);
+    }
+    async saveStrategyVariant(variant) {
+        if (!this.pool)
+            throw new Error('Database not connected');
+        await this.pool.query(`INSERT INTO futures_strategy_variants (strategy_name, variant_name, variables, enabled)
+       VALUES ($1, $2, $3, $4)
+       ON CONFLICT (strategy_name, variant_name)
+       DO UPDATE SET variables = $3, enabled = $4`, [variant.strategyName, variant.variantName, JSON.stringify(variant.variables), variant.enabled]);
+    }
+    async getStrategyVariants(strategyName) {
+        if (!this.pool)
+            throw new Error('Database not connected');
+        const result = await this.pool.query(`SELECT * FROM futures_strategy_variants WHERE strategy_name = $1 AND enabled = true`, [strategyName]);
+        return result.rows.map(row => ({
+            strategyName: row.strategy_name,
+            variantName: row.variant_name,
+            variables: row.variables,
+            enabled: row.enabled,
+        }));
+    }
+    async disconnect() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+            this.initialized = false;
+            logger_1.logger.info('Disconnected from futures database');
+        }
+    }
+}
+exports.FuturesDatabase = FuturesDatabase;
+// =============================================================================
+// STRATEGY ENGINE
+// =============================================================================
+class StrategyEngine {
+    strategies = new Map();
+    variants = new Map();
+    activePositions = new Map();
+    db = null;
+    service = null;
+    registerStrategy(strategy) {
+        this.strategies.set(strategy.name, strategy);
+        logger_1.logger.info({ strategy: strategy.name, version: strategy.version }, 'Registered strategy');
+    }
+    addVariant(variant) {
+        const variants = this.variants.get(variant.strategyName) || [];
+        variants.push(variant);
+        this.variants.set(variant.strategyName, variants);
+        logger_1.logger.info({ strategy: variant.strategyName, variant: variant.variantName }, 'Added strategy variant');
+    }
+    async loadVariantsFromDb(db) {
+        this.db = db;
+        for (const strategyName of this.strategies.keys()) {
+            const variants = await db.getStrategyVariants(strategyName);
+            this.variants.set(strategyName, variants);
+        }
+    }
+    connectService(service) {
+        this.service = service;
+    }
+    getStrategies() {
+        return Array.from(this.strategies.keys());
+    }
+    getVariants(strategyName) {
+        return this.variants.get(strategyName) || [];
+    }
+    async evaluateEntry(exchange, market, strategyName, variantName) {
+        const strategy = this.strategies.get(strategyName);
+        if (!strategy)
+            throw new Error(`Strategy ${strategyName} not found`);
+        // Get variant variables or use defaults
+        let variables = {};
+        if (variantName) {
+            const variants = this.variants.get(strategyName) || [];
+            const variant = variants.find(v => v.variantName === variantName);
+            if (variant) {
+                variables = variant.variables;
+            }
+        }
+        // Fill in defaults for missing variables
+        for (const v of strategy.variables) {
+            if (variables[v.name] === undefined && typeof v.default === 'number') {
+                variables[v.name] = v.default;
+            }
+        }
+        const signal = await strategy.entryCondition(market, variables);
+        return { signal, variables };
+    }
+    async executeTrade(exchange, symbol, signal, strategyName, variantName, variables) {
+        if (!this.service)
+            throw new Error('FuturesService not connected');
+        if (!this.db)
+            throw new Error('Database not connected');
+        const strategy = this.strategies.get(strategyName);
+        if (!strategy)
+            throw new Error(`Strategy ${strategyName} not found`);
+        const balance = await this.service.getBalance(exchange);
+        const markets = await this.service.getMarkets(exchange);
+        const market = markets.find(m => m.symbol === symbol);
+        if (!market)
+            throw new Error(`Market ${symbol} not found`);
+        const numVariables = variables;
+        const size = strategy.calculateSize?.(balance, market, numVariables) || balance.available * 0.1 / market.markPrice;
+        const leverage = strategy.calculateLeverage?.(market, numVariables) || 10;
+        const order = signal === 'LONG'
+            ? await this.service.openLong(exchange, symbol, size, leverage)
+            : await this.service.openShort(exchange, symbol, size, leverage);
+        // Record trade in database
+        const tradeId = await this.db.recordTrade({
+            exchange,
+            symbol,
+            side: signal,
+            entryPrice: order.avgFillPrice || market.markPrice,
+            size: order.size,
+            leverage,
+            entryTime: new Date(),
+            strategy: strategyName,
+            strategyVariant: variantName,
+            variables,
+        });
+        // Track active position
+        const posKey = `${exchange}:${symbol}`;
+        this.activePositions.set(posKey, { tradeId, strategy: strategyName, variant: variantName });
+        logger_1.logger.info({
+            tradeId,
+            exchange,
+            symbol,
+            signal,
+            strategy: strategyName,
+            variant: variantName,
+            variables,
+        }, 'Executed strategy trade');
+        return order;
+    }
+    async closeTrade(exchange, symbol, exitPrice) {
+        if (!this.db)
+            throw new Error('Database not connected');
+        const posKey = `${exchange}:${symbol}`;
+        const activePos = this.activePositions.get(posKey);
+        if (!activePos)
+            return;
+        // Get original trade to calculate PnL
+        const trades = await this.db.getTrades({ strategy: activePos.strategy, limit: 1 });
+        const trade = trades.find(t => t.id === activePos.tradeId);
+        if (!trade)
+            return;
+        const pnl = trade.side === 'LONG'
+            ? (exitPrice - trade.entryPrice) * trade.size
+            : (trade.entryPrice - exitPrice) * trade.size;
+        const pnlPct = (pnl / (trade.entryPrice * trade.size)) * 100 * trade.leverage;
+        await this.db.updateTrade(activePos.tradeId, {
+            exitPrice,
+            exitTime: new Date(),
+            pnl,
+            pnlPct,
+        });
+        this.activePositions.delete(posKey);
+        logger_1.logger.info({
+            tradeId: activePos.tradeId,
+            exchange,
+            symbol,
+            exitPrice,
+            pnl,
+            pnlPct: pnlPct.toFixed(2) + '%',
+        }, 'Closed strategy trade');
+    }
+    async runABTest(exchange, symbol, strategyName, durationMinutes = 60) {
+        const variants = this.variants.get(strategyName) || [];
+        if (variants.length < 2) {
+            throw new Error('Need at least 2 variants for A/B testing');
+        }
+        logger_1.logger.info({
+            strategy: strategyName,
+            variants: variants.map(v => v.variantName),
+            duration: durationMinutes,
+        }, 'Starting A/B test');
+        // Rotate through variants
+        let variantIndex = 0;
+        const endTime = Date.now() + durationMinutes * 60 * 1000;
+        while (Date.now() < endTime) {
+            const variant = variants[variantIndex % variants.length];
+            variantIndex++;
+            if (!this.service)
+                break;
+            const markets = await this.service.getMarkets(exchange);
+            const market = markets.find(m => m.symbol === symbol);
+            if (!market)
+                continue;
+            const { signal, variables } = await this.evaluateEntry(exchange, market, strategyName, variant.variantName);
+            if (signal) {
+                await this.executeTrade(exchange, symbol, signal, strategyName, variant.variantName, variables);
+            }
+            // Wait before next evaluation
+            await new Promise(resolve => setTimeout(resolve, 60000));
+        }
+        logger_1.logger.info({ strategy: strategyName }, 'A/B test completed');
+    }
+}
+exports.StrategyEngine = StrategyEngine;
+// =============================================================================
+// UNIFIED FUTURES SERVICE
+// =============================================================================
+class FuturesService extends events_1.EventEmitter {
+    clients = new Map();
+    config;
+    positionMonitorInterval = null;
+    db = null;
+    strategyEngine = null;
+    hlPrefs = new Map();
+    constructor(configs) {
+        super();
+        this.config = configs;
+        for (const config of configs) {
+            this.initClient(config);
+        }
+    }
+    async connectDatabase(config) {
+        this.db = new FuturesDatabase();
+        await this.db.connect(config);
+        await this.db.initialize();
+    }
+    enableStrategies() {
+        if (!this.strategyEngine) {
+            this.strategyEngine = new StrategyEngine();
+            this.strategyEngine.connectService(this);
+            if (this.db) {
+                this.strategyEngine.loadVariantsFromDb(this.db);
+            }
+        }
+        return this.strategyEngine;
+    }
+    getDatabase() {
+        return this.db;
+    }
+    getStrategyEngine() {
+        return this.strategyEngine;
+    }
+    initClient(config) {
+        switch (config.exchange) {
+            case 'binance':
+                this.clients.set('binance', new BinanceFuturesClient(config.credentials, config.dryRun));
+                break;
+            case 'bybit':
+                this.clients.set('bybit', new BybitFuturesClient(config.credentials, config.dryRun));
+                break;
+            case 'hyperliquid':
+                this.clients.set('hyperliquid', new HyperliquidClient(config.credentials, config.dryRun));
+                break;
+            case 'mexc':
+                this.clients.set('mexc', new MexcFuturesClient(config.credentials, config.dryRun));
+                break;
+        }
+        logger_1.logger.info({ exchange: config.exchange }, 'Initialized futures client');
+    }
+    getClient(exchange) {
+        const client = this.clients.get(exchange);
+        if (!client) {
+            throw new Error(`Exchange ${exchange} not configured`);
+        }
+        return client;
+    }
+    async getBalance(exchange) {
+        return this.getClient(exchange).getBalance();
+    }
+    async getAllBalances() {
+        const balances = await Promise.all(Array.from(this.clients.keys()).map(ex => this.getBalance(ex)));
+        return balances;
+    }
+    async getPositions(exchange) {
+        return this.getClient(exchange).getPositions();
+    }
+    async getAllPositions() {
+        const positions = await Promise.all(Array.from(this.clients.keys()).map(ex => this.getPositions(ex)));
+        return positions.flat();
+    }
+    async placeOrder(exchange, order) {
+        const config = this.config.find(c => c.exchange === exchange);
+        if (config?.maxLeverage && order.leverage && order.leverage > config.maxLeverage) {
+            throw new Error(`Leverage ${order.leverage}x exceeds max ${config.maxLeverage}x`);
+        }
+        const result = await this.getClient(exchange).placeOrder(order);
+        this.emit('order', result);
+        logger_1.logger.info({
+            exchange,
+            symbol: order.symbol,
+            side: order.side,
+            size: order.size,
+            leverage: order.leverage,
+        }, 'Placed futures order');
+        return result;
+    }
+    async openLong(exchange, symbol, size, leverage, options) {
+        return this.placeOrder(exchange, {
+            symbol,
+            side: 'BUY',
+            type: options?.price ? 'LIMIT' : 'MARKET',
+            size,
+            leverage,
+            price: options?.price,
+            takeProfit: options?.takeProfit,
+            stopLoss: options?.stopLoss,
+        });
+    }
+    async openShort(exchange, symbol, size, leverage, options) {
+        return this.placeOrder(exchange, {
+            symbol,
+            side: 'SELL',
+            type: options?.price ? 'LIMIT' : 'MARKET',
+            size,
+            leverage,
+            price: options?.price,
+            takeProfit: options?.takeProfit,
+            stopLoss: options?.stopLoss,
+        });
+    }
+    async closePosition(exchange, symbol) {
+        const result = await this.getClient(exchange).closePosition(symbol);
+        if (result) {
+            this.emit('positionClosed', result);
+            logger_1.logger.info({ exchange, symbol }, 'Closed futures position');
+        }
+        return result;
+    }
+    async closeAllPositions(exchange) {
+        const positions = await this.getPositions(exchange);
+        const results = await Promise.all(positions.map(p => this.closePosition(exchange, p.symbol)));
+        return results.filter((r) => r !== null);
+    }
+    async cancelOrder(exchange, symbol, orderId) {
+        await this.getClient(exchange).cancelOrder(symbol, orderId);
+        this.emit('orderCanceled', { exchange, symbol, orderId });
+    }
+    async getMarkets(exchange) {
+        return this.getClient(exchange).getMarkets();
+    }
+    async getFundingRate(exchange, symbol) {
+        const client = this.getClient(exchange);
+        if ('getFundingRate' in client) {
+            return client.getFundingRate(symbol);
+        }
+        throw new Error(`getFundingRate not supported on ${exchange}`);
+    }
+    async getOpenOrders(exchange, symbol) {
+        const client = this.getClient(exchange);
+        if ('getOpenOrders' in client) {
+            return client.getOpenOrders(symbol);
+        }
+        return [];
+    }
+    startPositionMonitor(intervalMs = 5000) {
+        if (this.positionMonitorInterval)
+            return;
+        this.positionMonitorInterval = setInterval(async () => {
+            try {
+                const positions = await this.getAllPositions();
+                for (const position of positions) {
+                    if (position.liquidationPrice <= 0)
+                        continue;
+                    const priceDiff = Math.abs(position.markPrice - position.liquidationPrice);
+                    const liqProximity = (priceDiff / position.markPrice) * 100;
+                    if (liqProximity < 5) {
+                        const level = liqProximity < 2 ? 'critical' : liqProximity < 3 ? 'danger' : 'warning';
+                        this.emit('liquidationWarning', {
+                            level,
+                            position,
+                            proximityPct: liqProximity,
+                        });
+                        logger_1.logger.warn({
+                            level,
+                            exchange: position.exchange,
+                            symbol: position.symbol,
+                            proximityPct: liqProximity.toFixed(2),
+                        }, 'Liquidation warning');
+                    }
+                }
+            }
+            catch (err) {
+                logger_1.logger.error({ err }, 'Position monitor error');
+            }
+        }, intervalMs);
+        logger_1.logger.info({ intervalMs }, 'Started position monitor');
+    }
+    stopPositionMonitor() {
+        if (this.positionMonitorInterval) {
+            clearInterval(this.positionMonitorInterval);
+            this.positionMonitorInterval = null;
+            logger_1.logger.info('Stopped position monitor');
+        }
+    }
+    getExchanges() {
+        return Array.from(this.clients.keys());
+    }
+    async setMarginType(exchange, symbol, marginType) {
+        const client = this.getClient(exchange);
+        switch (exchange) {
+            case 'binance':
+                await client.setMarginType(symbol, marginType);
+                break;
+            case 'bybit': {
+                // Bybit: 0 = cross, 1 = isolated
+                const tradeMode = marginType === 'CROSS' ? 0 : 1;
+                // Read current leverage from position to avoid resetting it
+                const bybitClient = client;
+                const bybitPositions = await bybitClient.getPositions();
+                const bybitPos = bybitPositions.find(p => p.symbol === symbol);
+                const bybitLeverage = bybitPos?.leverage || undefined;
+                try {
+                    await bybitClient.setIsolatedMargin(symbol, tradeMode, bybitLeverage);
+                }
+                catch (err) {
+                    const msg = err.message;
+                    // Already set to this mode
+                    if (!msg.includes('not modified') && !msg.includes('same'))
+                        throw err;
+                }
+                break;
+            }
+            case 'hyperliquid': {
+                // Get current leverage from position or local prefs
+                const hlClient = client;
+                const hlPositions = await hlClient.getPositions();
+                const hlPos = hlPositions.find(p => p.symbol === symbol);
+                const prefs = this.hlPrefs.get(symbol) || {};
+                const currentLeverage = hlPos?.leverage || prefs.leverage || 10;
+                prefs.marginType = marginType;
+                this.hlPrefs.set(symbol, prefs);
+                await hlClient.setLeverage(symbol, currentLeverage, marginType);
+                break;
+            }
+            case 'mexc':
+                // MEXC applies margin type per-order via openType param
+                client.setMarginTypePreference(marginType);
+                logger_1.logger.info({ symbol, marginType }, 'MEXC margin type set (applied to all future orders)');
+                break;
+        }
+    }
+    async setLeverage(exchange, symbol, leverage) {
+        const client = this.getClient(exchange);
+        if (exchange === 'hyperliquid') {
+            // Preserve current margin type when setting leverage
+            const hlClient = client;
+            const positions = await hlClient.getPositions();
+            const pos = positions.find(p => p.symbol === symbol);
+            const prefs = this.hlPrefs.get(symbol) || {};
+            const currentMarginType = pos?.marginType || prefs.marginType || 'CROSS';
+            prefs.leverage = leverage;
+            this.hlPrefs.set(symbol, prefs);
+            await hlClient.setLeverage(symbol, leverage, currentMarginType);
+        }
+        else if ('setLeverage' in client) {
+            await client.setLeverage(symbol, leverage);
+        }
+    }
+    async getIncomeHistory(exchange, params) {
+        const client = this.getClient(exchange);
+        if (exchange === 'binance') {
+            return client.getIncomeHistory(params?.symbol, undefined, params?.limit);
+        }
+        if (exchange === 'bybit') {
+            return client.getIncomeHistory(params?.symbol, params?.limit);
+        }
+        if (exchange === 'mexc') {
+            // MEXC uses position history for realized PnL
+            const mexcClient = client;
+            const history = await mexcClient.getPositionHistory(params?.symbol, params?.limit || 50);
+            return history.map(h => ({
+                symbol: h.symbol,
+                incomeType: 'REALIZED_PNL',
+                income: h.realizedPnl,
+                asset: 'USDT',
+                timestamp: h.closeTime,
+            }));
+        }
+        if (exchange === 'hyperliquid') {
+            // Hyperliquid uses trade fills with closedPnl
+            const hlClient = client;
+            const trades = await hlClient.getTradeHistory(params?.limit || 50);
+            const filtered = params?.symbol
+                ? trades.filter(t => t.symbol === params.symbol)
+                : trades;
+            return filtered
+                .filter(t => t.realizedPnl !== 0)
+                .map(t => ({
+                symbol: t.symbol,
+                incomeType: 'REALIZED_PNL',
+                income: t.realizedPnl,
+                asset: 'USDC',
+                timestamp: t.timestamp,
+            }));
+        }
+        return [];
+    }
+    async getTradeHistory(exchange, symbol, limit) {
+        const client = this.getClient(exchange);
+        switch (exchange) {
+            case 'binance': {
+                if (!symbol)
+                    throw new Error('Binance requires symbol for trade history');
+                return client.getTradeHistory(symbol, limit);
+            }
+            case 'bybit':
+                return client.getTradeHistory(symbol, limit);
+            case 'hyperliquid': {
+                const trades = await client.getTradeHistory(limit);
+                return symbol ? trades.filter(t => t.symbol === symbol) : trades;
+            }
+            case 'mexc':
+                return client.getTradeHistory(symbol, limit);
+            default:
+                return [];
+        }
+    }
+    async getOrderHistory(exchange, symbol, limit) {
+        const client = this.getClient(exchange);
+        switch (exchange) {
+            case 'binance':
+                return client.getOrderHistory(symbol, limit);
+            case 'bybit':
+                return client.getOrderHistory(symbol, limit);
+            case 'hyperliquid': {
+                const orders = await client.getOrderHistory();
+                const filtered = symbol ? orders.filter(o => o.symbol === symbol) : orders;
+                return limit ? filtered.slice(0, limit) : filtered;
+            }
+            case 'mexc':
+                return client.getOrderHistory(symbol, limit);
+            default:
+                return [];
+        }
+    }
+    async getAccountInfo(exchange) {
+        const client = this.getClient(exchange);
+        return client.getAccountInfo();
+    }
+    async getOrderBook(exchange, symbol, limit) {
+        const client = this.getClient(exchange);
+        if (exchange === 'hyperliquid') {
+            return client.getOrderBook(symbol);
+        }
+        return client.getOrderBook(symbol, limit);
+    }
+    async getTickerPrice(exchange, symbol) {
+        const client = this.getClient(exchange);
+        if ('getTickerPrice' in client) {
+            return client.getTickerPrice(symbol);
+        }
+        // Hyperliquid doesn't have a direct ticker API, use order book mid price
+        if (symbol) {
+            const book = await client.getOrderBook(symbol);
+            if (book.bids.length > 0 && book.asks.length > 0) {
+                const mid = (book.bids[0][0] + book.asks[0][0]) / 2;
+                return [{ symbol, price: mid, timestamp: Date.now() }];
+            }
+        }
+        return [];
+    }
+}
+exports.FuturesService = FuturesService;
+// =============================================================================
+// FACTORY & EASY SETUP
+// =============================================================================
+function createFuturesService(configs) {
+    return new FuturesService(configs);
+}
+/**
+ * Easy setup from environment variables
+ *
+ * Required env vars (at least one exchange):
+ * - BINANCE_API_KEY, BINANCE_API_SECRET
+ * - BYBIT_API_KEY, BYBIT_API_SECRET
+ * - HYPERLIQUID_WALLET, HYPERLIQUID_PRIVATE_KEY
+ *
+ * Optional:
+ * - FUTURES_DATABASE_URL (for trade tracking)
+ * - DRY_RUN=true (paper trading)
+ */
+async function setupFromEnv() {
+    const configs = [];
+    const dryRun = process.env.DRY_RUN === 'true';
+    // Binance
+    if (process.env.BINANCE_API_KEY && process.env.BINANCE_API_SECRET) {
+        configs.push({
+            exchange: 'binance',
+            credentials: {
+                apiKey: process.env.BINANCE_API_KEY,
+                apiSecret: process.env.BINANCE_API_SECRET,
+                testnet: process.env.BINANCE_TESTNET === 'true',
+            },
+            dryRun,
+            maxLeverage: 125,
+        });
+    }
+    // Bybit
+    if (process.env.BYBIT_API_KEY && process.env.BYBIT_API_SECRET) {
+        configs.push({
+            exchange: 'bybit',
+            credentials: {
+                apiKey: process.env.BYBIT_API_KEY,
+                apiSecret: process.env.BYBIT_API_SECRET,
+                testnet: process.env.BYBIT_TESTNET === 'true',
+            },
+            dryRun,
+            maxLeverage: 100,
+        });
+    }
+    // Hyperliquid
+    if (process.env.HYPERLIQUID_WALLET && process.env.HYPERLIQUID_PRIVATE_KEY) {
+        configs.push({
+            exchange: 'hyperliquid',
+            credentials: {
+                apiKey: process.env.HYPERLIQUID_WALLET,
+                apiSecret: process.env.HYPERLIQUID_PRIVATE_KEY,
+            },
+            dryRun,
+            maxLeverage: 50,
+        });
+    }
+    // MEXC (No KYC for small amounts - up to 200x leverage)
+    if (process.env.MEXC_API_KEY && process.env.MEXC_API_SECRET) {
+        configs.push({
+            exchange: 'mexc',
+            credentials: {
+                apiKey: process.env.MEXC_API_KEY,
+                apiSecret: process.env.MEXC_API_SECRET,
+            },
+            dryRun,
+            maxLeverage: 200,
+        });
+    }
+    if (configs.length === 0) {
+        throw new Error('No exchange credentials found in environment variables');
+    }
+    const service = new FuturesService(configs);
+    // Connect database if configured
+    let db = null;
+    if (process.env.FUTURES_DATABASE_URL) {
+        await service.connectDatabase({ connectionString: process.env.FUTURES_DATABASE_URL });
+        db = service.getDatabase();
+    }
+    // Enable strategy engine
+    const strategies = service.enableStrategies();
+    return { service, db, strategies };
+}
+// =============================================================================
+// EXAMPLE STRATEGIES (Ready to use or customize)
+// =============================================================================
+/**
+ * Simple momentum strategy
+ * Buys when funding is negative (shorts paying longs)
+ * Sells when funding is positive (longs paying shorts)
+ */
+exports.MomentumStrategy = {
+    name: 'momentum',
+    version: '1.0.0',
+    description: 'Trade based on funding rate direction',
+    variables: [
+        { name: 'fundingThreshold', type: 'number', default: 0.01, min: 0.001, max: 0.1, step: 0.001, description: 'Minimum funding rate to trigger' },
+        { name: 'leverage', type: 'number', default: 10, min: 1, max: 50, step: 1, description: 'Position leverage' },
+        { name: 'positionPct', type: 'number', default: 10, min: 1, max: 50, step: 1, description: 'Percentage of balance to use' },
+    ],
+    entryCondition: async (market, variables) => {
+        if (market.fundingRate < -variables.fundingThreshold)
+            return 'LONG';
+        if (market.fundingRate > variables.fundingThreshold)
+            return 'SHORT';
+        return null;
+    },
+    calculateSize: (balance, market, variables) => {
+        return (balance.available * (variables.positionPct / 100)) / market.markPrice;
+    },
+    calculateLeverage: (_market, variables) => variables.leverage,
+};
+/**
+ * Mean reversion strategy
+ * Buys oversold, sells overbought based on price deviation
+ */
+exports.MeanReversionStrategy = {
+    name: 'mean_reversion',
+    version: '1.0.0',
+    description: 'Trade reversions to mean price',
+    variables: [
+        { name: 'deviationPct', type: 'number', default: 2, min: 0.5, max: 10, step: 0.5, description: 'Price deviation % to trigger' },
+        { name: 'leverage', type: 'number', default: 5, min: 1, max: 25, step: 1, description: 'Position leverage' },
+        { name: 'positionPct', type: 'number', default: 5, min: 1, max: 25, step: 1, description: 'Percentage of balance to use' },
+    ],
+    entryCondition: async (market, variables) => {
+        const deviation = ((market.markPrice - market.indexPrice) / market.indexPrice) * 100;
+        if (deviation < -variables.deviationPct)
+            return 'LONG'; // Oversold
+        if (deviation > variables.deviationPct)
+            return 'SHORT'; // Overbought
+        return null;
+    },
+    calculateSize: (balance, market, variables) => {
+        return (balance.available * (variables.positionPct / 100)) / market.markPrice;
+    },
+    calculateLeverage: (_market, variables) => variables.leverage,
+};
+/**
+ * Grid trading strategy
+ * Places orders at regular price intervals
+ */
+exports.GridStrategy = {
+    name: 'grid',
+    version: '1.0.0',
+    description: 'Grid trading with price levels',
+    variables: [
+        { name: 'gridSpacingPct', type: 'number', default: 1, min: 0.1, max: 5, step: 0.1, description: 'Grid spacing %' },
+        { name: 'gridLevels', type: 'number', default: 5, min: 2, max: 20, step: 1, description: 'Number of grid levels' },
+        { name: 'leverage', type: 'number', default: 3, min: 1, max: 10, step: 1, description: 'Position leverage' },
+        { name: 'positionPct', type: 'number', default: 20, min: 5, max: 50, step: 5, description: 'Total capital for grid' },
+    ],
+    entryCondition: async (_market, _variables) => {
+        // Grid strategy manages entries differently - always check for opportunities
+        return null; // Managed by grid logic
+    },
+    calculateSize: (balance, market, variables) => {
+        const totalCapital = balance.available * (variables.positionPct / 100);
+        const perLevel = totalCapital / variables.gridLevels;
+        return perLevel / market.markPrice;
+    },
+    calculateLeverage: (_market, variables) => variables.leverage,
+};
+//# sourceMappingURL=index.js.map