clodds 1.1.0

package/dist/execution/futures.js

@@ -0,0 +1,1336 @@
+"use strict";
+/**
+ * Futures Execution Service - Perpetuals/Futures trading infrastructure
+ *
+ * Supports: Binance Futures, Bybit, MEXC, Hyperliquid
+ *
+ * Key differences from prediction market ExecutionService:
+ * - Long/short positions (not yes/no outcomes)
+ * - Leverage support
+ * - Margin types (isolated/cross)
+ * - Position sizing in contracts or base currency
+ * - Funding rates awareness
+ */
+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.createFuturesExecutionService = createFuturesExecutionService;
+const logger_1 = require("../utils/logger");
+const crypto_1 = require("crypto");
+const ethers_1 = require("ethers");
+const bybit = __importStar(require("../exchanges/bybit"));
+const mexc = __importStar(require("../exchanges/mexc"));
+const hyperliquid = __importStar(require("../exchanges/hyperliquid"));
+// Helper to derive wallet address from private key
+function getWalletAddress(privateKey) {
+    const wallet = new ethers_1.Wallet(privateKey.startsWith('0x') ? privateKey : `0x${privateKey}`);
+    return wallet.address;
+}
+// =============================================================================
+// MEXC margin type preference (per-order, tracked locally)
+// =============================================================================
+const mexcMarginPreference = new Map();
+// =============================================================================
+// BINANCE FUTURES
+// =============================================================================
+const BINANCE_FUTURES_URL = 'https://fapi.binance.com';
+const BINANCE_FUTURES_TESTNET_URL = 'https://testnet.binancefuture.com';
+function getBinanceUrl(testnet) {
+    return testnet ? BINANCE_FUTURES_TESTNET_URL : BINANCE_FUTURES_URL;
+}
+function signBinanceRequest(params, secretKey) {
+    const queryString = Object.entries(params)
+        .map(([k, v]) => `${k}=${v}`)
+        .join('&');
+    return (0, crypto_1.createHmac)('sha256', secretKey).update(queryString).digest('hex');
+}
+async function binanceFuturesRequest(config, method, endpoint, params = {}) {
+    const baseUrl = getBinanceUrl(config.testnet);
+    const timestamp = Date.now();
+    const allParams = { ...params, timestamp, recvWindow: 5000 };
+    const signature = signBinanceRequest(allParams, config.secretKey);
+    const queryString = Object.entries(allParams)
+        .map(([k, v]) => `${k}=${encodeURIComponent(v)}`)
+        .join('&') + `&signature=${signature}`;
+    const url = `${baseUrl}${endpoint}?${queryString}`;
+    const response = await fetch(url, {
+        method,
+        headers: {
+            'X-MBX-APIKEY': config.apiKey,
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+    });
+    const data = await response.json();
+    if (!response.ok) {
+        throw new Error(data.msg || `HTTP ${response.status}`);
+    }
+    return data;
+}
+async function placeBinanceFuturesOrder(config, request) {
+    try {
+        const params = {
+            symbol: request.symbol,
+            side: request.side === 'long' ? 'BUY' : 'SELL',
+            type: request.orderType || 'MARKET',
+            quantity: request.size,
+        };
+        if (request.price && (request.orderType === 'LIMIT' || request.orderType === 'STOP_LIMIT' || request.orderType === 'TAKE_PROFIT_LIMIT')) {
+            params.price = request.price;
+        }
+        if (request.timeInForce) {
+            params.timeInForce = request.timeInForce;
+        }
+        else if (request.orderType === 'LIMIT') {
+            params.timeInForce = 'GTC';
+        }
+        if (request.reduceOnly) {
+            params.reduceOnly = 'true';
+        }
+        if (request.stopPrice) {
+            params.stopPrice = request.stopPrice;
+        }
+        if (request.closePosition) {
+            params.closePosition = 'true';
+        }
+        const data = await binanceFuturesRequest(config, 'POST', '/fapi/v1/order', params);
+        return {
+            success: true,
+            orderId: data.orderId?.toString(),
+            clientOrderId: data.clientOrderId,
+            filledSize: parseFloat(data.executedQty || '0'),
+            avgFillPrice: parseFloat(data.avgPrice || '0'),
+            status: data.status,
+            commission: parseFloat(data.commission || '0'),
+            commissionAsset: data.commissionAsset,
+        };
+    }
+    catch (error) {
+        logger_1.logger.error({ error, request }, 'Binance Futures order failed');
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+async function cancelBinanceFuturesOrder(config, symbol, orderId) {
+    try {
+        await binanceFuturesRequest(config, 'DELETE', '/fapi/v1/order', {
+            symbol,
+            orderId: parseInt(orderId, 10),
+        });
+        return true;
+    }
+    catch (error) {
+        logger_1.logger.error({ error, symbol, orderId }, 'Failed to cancel Binance Futures order');
+        return false;
+    }
+}
+async function getBinanceFuturesPositions(config, symbol) {
+    try {
+        const data = await binanceFuturesRequest(config, 'GET', '/fapi/v2/positionRisk');
+        return data
+            .filter(p => parseFloat(p.positionAmt) !== 0)
+            .filter(p => !symbol || p.symbol === symbol)
+            .map(p => ({
+            platform: 'binance',
+            symbol: p.symbol,
+            side: parseFloat(p.positionAmt) > 0 ? 'long' : 'short',
+            size: Math.abs(parseFloat(p.positionAmt)),
+            entryPrice: parseFloat(p.entryPrice),
+            markPrice: parseFloat(p.markPrice),
+            liquidationPrice: parseFloat(p.liquidationPrice),
+            leverage: parseInt(p.leverage, 10),
+            marginType: p.marginType.toLowerCase(),
+            unrealizedPnl: parseFloat(p.unRealizedProfit),
+            margin: parseFloat(p.isolatedMargin),
+            notional: Math.abs(parseFloat(p.notional)),
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get Binance Futures positions');
+        return [];
+    }
+}
+async function getBinanceFuturesOpenOrders(config, symbol) {
+    try {
+        const params = {};
+        if (symbol)
+            params.symbol = symbol;
+        const data = await binanceFuturesRequest(config, 'GET', '/fapi/v1/openOrders', params);
+        return data.map(o => ({
+            orderId: o.orderId.toString(),
+            clientOrderId: o.clientOrderId,
+            platform: 'binance',
+            symbol: o.symbol,
+            side: o.side === 'BUY' ? 'long' : 'short',
+            price: parseFloat(o.price),
+            originalSize: parseFloat(o.origQty),
+            filledSize: parseFloat(o.executedQty),
+            remainingSize: parseFloat(o.origQty) - parseFloat(o.executedQty),
+            orderType: o.type,
+            timeInForce: o.timeInForce,
+            status: o.status,
+            reduceOnly: o.reduceOnly,
+            stopPrice: o.stopPrice ? parseFloat(o.stopPrice) : undefined,
+            createdAt: new Date(o.time),
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get Binance Futures open orders');
+        return [];
+    }
+}
+async function getBinanceFuturesBalance(config) {
+    try {
+        const data = await binanceFuturesRequest(config, 'GET', '/fapi/v2/account');
+        return data.assets
+            .filter(a => parseFloat(a.walletBalance) > 0 || parseFloat(a.marginBalance) > 0)
+            .map(a => ({
+            platform: 'binance',
+            asset: a.asset,
+            balance: parseFloat(a.walletBalance),
+            availableBalance: parseFloat(a.availableBalance),
+            unrealizedPnl: parseFloat(a.unrealizedProfit),
+            marginBalance: parseFloat(a.marginBalance),
+            maintenanceMargin: parseFloat(a.maintMargin),
+            initialMargin: parseFloat(a.initialMargin),
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get Binance Futures balance');
+        return [];
+    }
+}
+async function getBinanceFundingRate(config, symbol) {
+    try {
+        const data = await binanceFuturesRequest(config, 'GET', '/fapi/v1/premiumIndex', { symbol });
+        return {
+            platform: 'binance',
+            symbol: data.symbol,
+            fundingRate: parseFloat(data.lastFundingRate),
+            fundingTime: new Date(data.time),
+            nextFundingTime: new Date(data.nextFundingTime),
+            markPrice: parseFloat(data.markPrice),
+            indexPrice: parseFloat(data.indexPrice),
+        };
+    }
+    catch (error) {
+        logger_1.logger.error({ error, symbol }, 'Failed to get Binance funding rate');
+        return null;
+    }
+}
+async function setBinanceLeverage(config, symbol, leverage) {
+    try {
+        await binanceFuturesRequest(config, 'POST', '/fapi/v1/leverage', {
+            symbol,
+            leverage,
+        });
+        return true;
+    }
+    catch (error) {
+        logger_1.logger.error({ error, symbol, leverage }, 'Failed to set Binance leverage');
+        return false;
+    }
+}
+async function setBinanceMarginType(config, symbol, marginType) {
+    try {
+        await binanceFuturesRequest(config, 'POST', '/fapi/v1/marginType', {
+            symbol,
+            marginType: marginType.toUpperCase(),
+        });
+        return true;
+    }
+    catch (error) {
+        // Error code -4046 means margin type is already set
+        const errMsg = error instanceof Error ? error.message : '';
+        if (errMsg.includes('-4046')) {
+            return true;
+        }
+        logger_1.logger.error({ error, symbol, marginType }, 'Failed to set Binance margin type');
+        return false;
+    }
+}
+// =============================================================================
+// BYBIT FUTURES
+// =============================================================================
+async function placeBybitFuturesOrder(config, request) {
+    try {
+        const bybitConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+            testnet: config.testnet,
+        };
+        let result;
+        if (request.reduceOnly || request.closePosition) {
+            // Close position
+            const closeResult = await bybit.closePosition(bybitConfig, request.symbol);
+            if (!closeResult) {
+                return { success: true }; // No position to close
+            }
+            result = closeResult;
+        }
+        else if (request.orderType === 'LIMIT' && request.price) {
+            // Limit order
+            if (request.leverage) {
+                await bybit.setLeverage(bybitConfig, request.symbol, request.leverage);
+            }
+            result = await bybit.placeLimitOrder(bybitConfig, request.symbol, request.side === 'long' ? 'Buy' : 'Sell', request.size, request.price, { reduceOnly: request.reduceOnly, timeInForce: request.timeInForce });
+        }
+        else if ((request.orderType === 'STOP_LOSS' || request.orderType === 'TAKE_PROFIT') && request.stopPrice) {
+            // Stop order
+            result = await bybit.placeStopOrder(bybitConfig, request.symbol, request.side === 'long' ? 'Buy' : 'Sell', request.size, request.stopPrice, { price: request.price });
+        }
+        else if (request.side === 'long') {
+            result = await bybit.openLong(bybitConfig, request.symbol, request.size, request.leverage);
+        }
+        else {
+            result = await bybit.openShort(bybitConfig, request.symbol, request.size, request.leverage);
+        }
+        return {
+            success: true,
+            orderId: result.orderId,
+            filledSize: result.cumExecQty,
+            avgFillPrice: result.avgPrice,
+            status: result.orderStatus === 'Filled' ? 'FILLED' : 'NEW',
+        };
+    }
+    catch (error) {
+        logger_1.logger.error({ error, request }, 'Bybit Futures order failed');
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+async function cancelBybitFuturesOrder(config, symbol, orderId) {
+    try {
+        const bybitConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+            testnet: config.testnet,
+        };
+        return await bybit.cancelOrder(bybitConfig, symbol, orderId);
+    }
+    catch (error) {
+        logger_1.logger.error({ error, symbol, orderId }, 'Failed to cancel Bybit order');
+        return false;
+    }
+}
+async function getBybitFuturesPositions(config, symbol) {
+    try {
+        const bybitConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+            testnet: config.testnet,
+        };
+        const positions = await bybit.getPositions(bybitConfig);
+        return positions
+            .filter(p => !symbol || p.symbol === symbol)
+            .map(p => ({
+            platform: 'bybit',
+            symbol: p.symbol,
+            side: p.side === 'Buy' ? 'long' : 'short',
+            size: p.size,
+            entryPrice: p.entryPrice,
+            markPrice: p.markPrice,
+            liquidationPrice: p.liqPrice,
+            leverage: p.leverage,
+            marginType: 'isolated', // Bybit unified account
+            unrealizedPnl: p.unrealisedPnl,
+            margin: p.positionValue / p.leverage,
+            notional: p.positionValue,
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get Bybit positions');
+        return [];
+    }
+}
+async function getBybitFuturesOpenOrders(config, symbol) {
+    try {
+        const bybitConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+            testnet: config.testnet,
+        };
+        const orders = await bybit.getOpenOrders(bybitConfig, symbol);
+        return orders.map(o => ({
+            orderId: o.orderId,
+            platform: 'bybit',
+            symbol: o.symbol,
+            side: o.side === 'Buy' ? 'long' : 'short',
+            price: o.price,
+            originalSize: o.qty,
+            filledSize: o.cumExecQty,
+            remainingSize: o.qty - o.cumExecQty,
+            orderType: (o.orderType === 'Market' ? 'MARKET' : 'LIMIT'),
+            timeInForce: 'GTC',
+            status: o.orderStatus,
+            reduceOnly: false,
+            createdAt: new Date(),
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get Bybit open orders');
+        return [];
+    }
+}
+async function getBybitFuturesBalance(config) {
+    try {
+        const bybitConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+            testnet: config.testnet,
+        };
+        const balances = await bybit.getBalance(bybitConfig);
+        return balances.map(b => ({
+            platform: 'bybit',
+            asset: b.coin,
+            balance: b.walletBalance,
+            availableBalance: b.availableBalance,
+            unrealizedPnl: b.unrealisedPnl,
+            marginBalance: b.equity,
+            maintenanceMargin: 0,
+            initialMargin: b.equity - b.availableBalance,
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get Bybit balance');
+        return [];
+    }
+}
+async function getBybitFundingRate(config, symbol) {
+    try {
+        const bybitConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+            testnet: config.testnet,
+        };
+        const data = await bybit.getFundingRate(bybitConfig, symbol);
+        return {
+            platform: 'bybit',
+            symbol: data.symbol,
+            fundingRate: data.fundingRate,
+            fundingTime: new Date(),
+            nextFundingTime: new Date(data.fundingRateTimestamp),
+            markPrice: data.markPrice,
+            indexPrice: data.indexPrice,
+        };
+    }
+    catch (error) {
+        logger_1.logger.error({ error, symbol }, 'Failed to get Bybit funding rate');
+        return null;
+    }
+}
+async function setBybitLeverage(config, symbol, leverage) {
+    try {
+        const bybitConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+            testnet: config.testnet,
+        };
+        await bybit.setLeverage(bybitConfig, symbol, leverage);
+        return true;
+    }
+    catch (error) {
+        logger_1.logger.error({ error, symbol, leverage }, 'Failed to set Bybit leverage');
+        return false;
+    }
+}
+// =============================================================================
+// MEXC FUTURES
+// =============================================================================
+async function placeMexcFuturesOrder(config, request) {
+    try {
+        const mexcConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+        };
+        const openType = mexcMarginPreference.get(request.symbol) === 'cross' ? 2 : 1;
+        let result;
+        if (request.reduceOnly || request.closePosition) {
+            result = await mexc.closePosition(mexcConfig, request.symbol);
+            if (!result) {
+                return { success: true }; // No position to close
+            }
+        }
+        else if (request.orderType === 'LIMIT' && request.price) {
+            // Limit order
+            const side = request.side === 'long'
+                ? (request.reduceOnly ? 4 : 1) // 1=open long, 4=close short
+                : (request.reduceOnly ? 2 : 3); // 3=open short, 2=close long
+            result = await mexc.placeLimitOrder(mexcConfig, request.symbol, side, request.size, request.price, { leverage: request.leverage, openType });
+        }
+        else if ((request.orderType === 'STOP_LOSS' || request.orderType === 'TAKE_PROFIT') && request.stopPrice) {
+            // Stop order
+            const side = request.side === 'long' ? 4 : 2; // Close sides for stops
+            result = await mexc.placeStopOrder(mexcConfig, request.symbol, side, request.size, request.stopPrice, { price: request.price, openType });
+        }
+        else if (request.side === 'long') {
+            result = await mexc.openLong(mexcConfig, request.symbol, request.size, request.leverage, openType);
+        }
+        else {
+            result = await mexc.openShort(mexcConfig, request.symbol, request.size, request.leverage, openType);
+        }
+        return {
+            success: true,
+            orderId: result.orderId,
+            filledSize: result.dealVol,
+            avgFillPrice: result.dealAvgPrice,
+            status: result.state === 2 ? 'FILLED' : 'NEW',
+        };
+    }
+    catch (error) {
+        logger_1.logger.error({ error, request }, 'MEXC Futures order failed');
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+async function cancelMexcFuturesOrder(config, symbol, orderId) {
+    try {
+        const mexcConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+        };
+        return await mexc.cancelOrder(mexcConfig, symbol, orderId);
+    }
+    catch (error) {
+        logger_1.logger.error({ error, symbol, orderId }, 'Failed to cancel MEXC order');
+        return false;
+    }
+}
+async function getMexcFuturesPositions(config, symbol) {
+    try {
+        const mexcConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+        };
+        const positions = await mexc.getPositions(mexcConfig);
+        return positions
+            .filter(p => !symbol || p.symbol === symbol)
+            .map(p => ({
+            platform: 'mexc',
+            symbol: p.symbol,
+            side: p.positionType === 1 ? 'long' : 'short',
+            size: p.holdVol,
+            entryPrice: p.openAvgPrice,
+            markPrice: p.markPrice,
+            liquidationPrice: p.liquidatePrice,
+            leverage: p.leverage,
+            marginType: 'isolated',
+            unrealizedPnl: p.unrealisedPnl,
+            margin: p.positionValue / p.leverage,
+            notional: p.positionValue,
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get MEXC positions');
+        return [];
+    }
+}
+async function getMexcFuturesOpenOrders(config, symbol) {
+    try {
+        const mexcConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+        };
+        const orders = await mexc.getOpenOrders(mexcConfig, symbol);
+        return orders.map(o => ({
+            orderId: o.orderId,
+            platform: 'mexc',
+            symbol: o.symbol,
+            side: (o.side === 1 || o.side === 2) ? 'long' : 'short',
+            price: o.price,
+            originalSize: o.vol,
+            filledSize: o.dealVol,
+            remainingSize: o.vol - o.dealVol,
+            orderType: (o.orderType === 5 ? 'MARKET' : 'LIMIT'),
+            timeInForce: 'GTC',
+            status: String(o.state),
+            reduceOnly: o.side === 2 || o.side === 4,
+            createdAt: new Date(),
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get MEXC open orders');
+        return [];
+    }
+}
+async function getMexcFuturesBalance(config) {
+    try {
+        const mexcConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+        };
+        const balances = await mexc.getBalance(mexcConfig);
+        return balances.map(b => ({
+            platform: 'mexc',
+            asset: b.currency,
+            balance: b.equity,
+            availableBalance: b.availableBalance,
+            unrealizedPnl: b.unrealisedPnl,
+            marginBalance: b.equity,
+            maintenanceMargin: 0,
+            initialMargin: b.frozenBalance,
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get MEXC balance');
+        return [];
+    }
+}
+async function getMexcFundingRate(config, symbol) {
+    try {
+        const mexcConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+        };
+        const data = await mexc.getFundingRate(mexcConfig, symbol);
+        return {
+            platform: 'mexc',
+            symbol: data.symbol,
+            fundingRate: data.fundingRate,
+            fundingTime: new Date(),
+            nextFundingTime: new Date(data.nextSettleTime),
+            markPrice: data.markPrice,
+            indexPrice: data.indexPrice,
+        };
+    }
+    catch (error) {
+        logger_1.logger.error({ error, symbol }, 'Failed to get MEXC funding rate');
+        return null;
+    }
+}
+async function setMexcLeverage(config, symbol, leverage) {
+    try {
+        const mexcConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+        };
+        await mexc.setLeverage(mexcConfig, symbol, leverage);
+        return true;
+    }
+    catch (error) {
+        logger_1.logger.error({ error, symbol, leverage }, 'Failed to set MEXC leverage');
+        return false;
+    }
+}
+// =============================================================================
+// HYPERLIQUID
+// =============================================================================
+async function placeHyperliquidOrder(config, request) {
+    try {
+        const walletAddress = getWalletAddress(config.privateKey);
+        const hlConfig = {
+            walletAddress,
+            privateKey: config.privateKey,
+            testnet: config.testnet,
+            vaultAddress: config.vaultAddress,
+        };
+        // Handle reduce-only / close position
+        if (request.reduceOnly || request.closePosition) {
+            const state = await hyperliquid.getUserState(walletAddress);
+            const position = state.assetPositions.find(p => p.position.coin === request.symbol);
+            if (!position || parseFloat(position.position.szi) === 0) {
+                return { success: true }; // No position to close
+            }
+            const positionSize = Math.abs(parseFloat(position.position.szi));
+            const isLong = parseFloat(position.position.szi) > 0;
+            const result = await hyperliquid.placePerpOrder(hlConfig, {
+                coin: request.symbol,
+                side: isLong ? 'SELL' : 'BUY',
+                size: positionSize,
+                type: 'MARKET',
+                reduceOnly: true,
+            });
+            return {
+                success: result.success,
+                orderId: result.orderId?.toString(),
+                error: result.error,
+            };
+        }
+        // Regular order (LIMIT or MARKET)
+        // Note: For stop/TP orders, Hyperliquid uses trigger orders via SDK.
+        // placePerpOrder handles LIMIT and MARKET; stop orders are placed as
+        // reduce-only market orders immediately (use trading/futures module
+        // for proper trigger-based stop orders with the raw API).
+        const result = await hyperliquid.placePerpOrder(hlConfig, {
+            coin: request.symbol,
+            side: request.side === 'long' ? 'BUY' : 'SELL',
+            size: request.size,
+            price: request.price,
+            type: request.orderType === 'LIMIT' ? 'LIMIT' : 'MARKET',
+            reduceOnly: request.reduceOnly,
+        });
+        return {
+            success: result.success,
+            orderId: result.orderId?.toString(),
+            error: result.error,
+        };
+    }
+    catch (error) {
+        logger_1.logger.error({ error, request }, 'Hyperliquid order failed');
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+async function cancelHyperliquidOrder(config, symbol, orderId) {
+    try {
+        const walletAddress = getWalletAddress(config.privateKey);
+        const hlConfig = {
+            walletAddress,
+            privateKey: config.privateKey,
+            testnet: config.testnet,
+            vaultAddress: config.vaultAddress,
+        };
+        const result = await hyperliquid.cancelOrder(hlConfig, symbol, parseInt(orderId, 10));
+        return result.success;
+    }
+    catch (error) {
+        logger_1.logger.error({ error, symbol, orderId }, 'Failed to cancel Hyperliquid order');
+        return false;
+    }
+}
+async function getHyperliquidPositions(config, symbol) {
+    try {
+        const walletAddress = getWalletAddress(config.privateKey);
+        const [state, mids] = await Promise.all([
+            hyperliquid.getUserState(walletAddress),
+            hyperliquid.getAllMids(),
+        ]);
+        return state.assetPositions
+            .filter(p => parseFloat(p.position.szi) !== 0)
+            .filter(p => !symbol || p.position.coin === symbol)
+            .map(p => {
+            const size = parseFloat(p.position.szi);
+            const entryPrice = parseFloat(p.position.entryPx);
+            const unrealizedPnl = parseFloat(p.position.unrealizedPnl);
+            const markPrice = parseFloat(mids[p.position.coin] || '0') || entryPrice;
+            const leverage = p.position.leverage?.value || 10;
+            const isCross = p.position.leverage?.type === 'cross';
+            const margin = parseFloat(p.position.marginUsed || '0') || Math.abs(size * markPrice) / leverage;
+            return {
+                platform: 'hyperliquid',
+                symbol: p.position.coin,
+                side: size > 0 ? 'long' : 'short',
+                size: Math.abs(size),
+                entryPrice,
+                markPrice,
+                liquidationPrice: parseFloat(p.position.liquidationPx || '0'),
+                leverage,
+                marginType: isCross ? 'cross' : 'isolated',
+                unrealizedPnl,
+                margin,
+                notional: Math.abs(size * markPrice),
+            };
+        });
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get Hyperliquid positions');
+        return [];
+    }
+}
+async function getHyperliquidOpenOrders(config, symbol) {
+    try {
+        const walletAddress = getWalletAddress(config.privateKey);
+        const orders = await hyperliquid.getOpenOrders(walletAddress);
+        return orders
+            .filter(o => !symbol || o.coin === symbol)
+            .map(o => ({
+            orderId: o.oid.toString(),
+            platform: 'hyperliquid',
+            symbol: o.coin,
+            side: o.side === 'B' ? 'long' : 'short',
+            price: parseFloat(o.limitPx),
+            originalSize: parseFloat(o.sz),
+            filledSize: 0,
+            remainingSize: parseFloat(o.sz),
+            orderType: 'LIMIT',
+            timeInForce: 'GTC',
+            status: 'open',
+            reduceOnly: false,
+            createdAt: new Date(o.timestamp),
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get Hyperliquid open orders');
+        return [];
+    }
+}
+async function getHyperliquidBalance(config) {
+    try {
+        const walletAddress = getWalletAddress(config.privateKey);
+        const state = await hyperliquid.getUserState(walletAddress);
+        const accountValue = parseFloat(state.marginSummary.accountValue);
+        const marginUsed = parseFloat(state.marginSummary.totalMarginUsed);
+        const unrealizedPnl = state.assetPositions.reduce((sum, p) => sum + parseFloat(p.position.unrealizedPnl || '0'), 0);
+        return [{
+                platform: 'hyperliquid',
+                asset: 'USDC',
+                balance: accountValue,
+                availableBalance: accountValue - marginUsed,
+                unrealizedPnl,
+                marginBalance: accountValue,
+                maintenanceMargin: marginUsed * 0.5,
+                initialMargin: marginUsed,
+            }];
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get Hyperliquid balance');
+        return [];
+    }
+}
+async function getHyperliquidFundingRate(symbol) {
+    try {
+        const [rates, mids] = await Promise.all([
+            hyperliquid.getFundingRates(),
+            hyperliquid.getAllMids(),
+        ]);
+        const rate = rates.find(r => r.coin === symbol);
+        if (!rate)
+            return null;
+        const midPrice = parseFloat(mids[symbol] || '0');
+        const premium = parseFloat(rate.premium || '0');
+        // HL index (oracle) price derived from mark and premium: index = mark / (1 + premium)
+        const indexPrice = premium !== 0 ? midPrice / (1 + premium) : midPrice;
+        return {
+            platform: 'hyperliquid',
+            symbol: rate.coin,
+            fundingRate: parseFloat(rate.funding),
+            fundingTime: new Date(),
+            nextFundingTime: new Date(Date.now() + 60 * 60 * 1000), // 1 hour
+            markPrice: midPrice,
+            indexPrice,
+        };
+    }
+    catch (error) {
+        logger_1.logger.error({ error, symbol }, 'Failed to get Hyperliquid funding rate');
+        return null;
+    }
+}
+async function setHyperliquidLeverage(config, symbol, leverage) {
+    try {
+        const walletAddress = getWalletAddress(config.privateKey);
+        const hlConfig = {
+            walletAddress,
+            privateKey: config.privateKey,
+            testnet: config.testnet,
+            vaultAddress: config.vaultAddress,
+        };
+        const result = await hyperliquid.updateLeverage(hlConfig, symbol, leverage, true);
+        return result.success;
+    }
+    catch (error) {
+        logger_1.logger.error({ error, symbol, leverage }, 'Failed to set Hyperliquid leverage');
+        return false;
+    }
+}
+async function getBinanceIncomeHistory(config, params) {
+    try {
+        const reqParams = { limit: params?.limit || 50 };
+        if (params?.symbol)
+            reqParams.symbol = params.symbol;
+        const data = await binanceFuturesRequest(config, 'GET', '/fapi/v1/income', reqParams);
+        return data.map(d => ({
+            symbol: d.symbol,
+            type: d.incomeType,
+            amount: parseFloat(d.income),
+            time: new Date(d.time),
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get Binance income history');
+        return [];
+    }
+}
+async function getBybitIncomeHistory(config, params) {
+    try {
+        const bybitConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+            testnet: config.testnet,
+        };
+        const records = await bybit.getIncomeHistory(bybitConfig, params);
+        return records.map(r => ({
+            symbol: r.symbol,
+            type: r.type,
+            amount: r.amount,
+            time: r.time,
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get Bybit income history');
+        return [];
+    }
+}
+async function getMexcIncomeHistory(config, params) {
+    try {
+        const mexcConfig = {
+            apiKey: config.apiKey,
+            apiSecret: config.secretKey,
+        };
+        const records = await mexc.getIncomeHistory(mexcConfig, params);
+        return records.map(r => ({
+            symbol: r.symbol,
+            type: r.type,
+            amount: r.amount,
+            time: r.time,
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get MEXC income history');
+        return [];
+    }
+}
+async function getHyperliquidIncomeHistory(hlConfig, params) {
+    try {
+        const walletAddress = getWalletAddress(hlConfig.privateKey);
+        const startTime = Date.now() - 30 * 24 * 60 * 60 * 1000; // 30 days
+        const data = await hyperliquid.getUserFunding(walletAddress, startTime);
+        return data
+            .filter(d => !params?.symbol || d.coin === params.symbol)
+            .slice(0, params?.limit || 50)
+            .map(d => ({
+            symbol: d.coin,
+            type: 'FUNDING',
+            amount: parseFloat(d.usdc),
+            time: new Date(d.time),
+        }));
+    }
+    catch (error) {
+        logger_1.logger.error({ error }, 'Failed to get Hyperliquid income history');
+        return [];
+    }
+}
+// =============================================================================
+// HYPERLIQUID MARGIN TYPE
+// =============================================================================
+async function setHyperliquidMarginType(hlConfig, symbol, marginType) {
+    try {
+        const walletAddress = getWalletAddress(hlConfig.privateKey);
+        const config = {
+            walletAddress,
+            privateKey: hlConfig.privateKey,
+            testnet: hlConfig.testnet,
+            vaultAddress: hlConfig.vaultAddress,
+        };
+        // Get current leverage from user state
+        const state = await hyperliquid.getUserState(walletAddress);
+        const position = state.assetPositions.find(p => p.position.coin === symbol);
+        const currentLeverage = position?.position.leverage?.value || 10;
+        const isCross = marginType === 'cross';
+        const result = await hyperliquid.updateLeverage(config, symbol, currentLeverage, isCross);
+        return result.success;
+    }
+    catch (error) {
+        logger_1.logger.error({ error, symbol, marginType }, 'Failed to set Hyperliquid margin type');
+        return false;
+    }
+}
+// =============================================================================
+// SERVICE FACTORY
+// =============================================================================
+function createFuturesExecutionService(config) {
+    const defaultLeverage = config.defaultLeverage || 10;
+    const defaultMarginType = config.defaultMarginType || 'isolated';
+    const maxPositionSize = config.maxPositionSize || 10000; // $10k default
+    async function executeOrder(request) {
+        // Validate position size
+        if (request.size * (request.price || 1) > maxPositionSize) {
+            return {
+                success: false,
+                error: `Position size exceeds max $${maxPositionSize}`,
+            };
+        }
+        // Dry run
+        if (config.dryRun) {
+            logger_1.logger.info({ ...request, dryRun: true }, 'Dry run futures order');
+            return {
+                success: true,
+                orderId: `dry_${(0, crypto_1.randomBytes)(8).toString('hex')}`,
+                status: 'FILLED',
+                filledSize: request.size,
+                avgFillPrice: request.price,
+            };
+        }
+        // Route to appropriate exchange
+        switch (request.platform) {
+            case 'binance':
+                if (!config.binance) {
+                    return { success: false, error: 'Binance Futures not configured' };
+                }
+                return placeBinanceFuturesOrder(config.binance, request);
+            case 'bybit':
+                if (!config.bybit) {
+                    return { success: false, error: 'Bybit not configured' };
+                }
+                return placeBybitFuturesOrder(config.bybit, request);
+            case 'mexc':
+                if (!config.mexc) {
+                    return { success: false, error: 'MEXC not configured' };
+                }
+                return placeMexcFuturesOrder(config.mexc, request);
+            case 'hyperliquid':
+                if (!config.hyperliquid) {
+                    return { success: false, error: 'Hyperliquid not configured' };
+                }
+                return placeHyperliquidOrder(config.hyperliquid, request);
+            default:
+                return { success: false, error: `Unknown platform: ${request.platform}` };
+        }
+    }
+    const service = {
+        async openLong(request) {
+            return executeOrder({
+                ...request,
+                side: 'long',
+                leverage: request.leverage || defaultLeverage,
+                marginType: request.marginType || defaultMarginType,
+            });
+        },
+        async openShort(request) {
+            return executeOrder({
+                ...request,
+                side: 'short',
+                leverage: request.leverage || defaultLeverage,
+                marginType: request.marginType || defaultMarginType,
+            });
+        },
+        async closeLong(request) {
+            return executeOrder({
+                ...request,
+                side: 'short', // Sell to close long
+                reduceOnly: true,
+            });
+        },
+        async closeShort(request) {
+            return executeOrder({
+                ...request,
+                side: 'long', // Buy to close short
+                reduceOnly: true,
+            });
+        },
+        async closePosition(platform, symbol) {
+            const positions = await this.getPositions(platform, symbol);
+            const position = positions.find(p => p.symbol === symbol);
+            if (!position) {
+                return { success: true }; // No position to close
+            }
+            return executeOrder({
+                platform,
+                symbol,
+                side: position.side === 'long' ? 'short' : 'long',
+                size: position.size,
+                orderType: 'MARKET',
+                reduceOnly: true,
+                closePosition: true,
+            });
+        },
+        async placeLimitOrder(request) {
+            return executeOrder({
+                ...request,
+                orderType: 'LIMIT',
+                timeInForce: request.timeInForce || 'GTC',
+            });
+        },
+        async placeMarketOrder(request) {
+            return executeOrder({
+                ...request,
+                orderType: 'MARKET',
+            });
+        },
+        async placeStopLoss(request) {
+            return executeOrder({
+                ...request,
+                orderType: 'STOP_LOSS',
+                reduceOnly: true,
+            });
+        },
+        async placeTakeProfit(request) {
+            return executeOrder({
+                ...request,
+                orderType: 'TAKE_PROFIT',
+                reduceOnly: true,
+            });
+        },
+        async cancelOrder(platform, symbol, orderId) {
+            if (config.dryRun) {
+                logger_1.logger.info({ platform, symbol, orderId, dryRun: true }, 'Dry run cancel');
+                return true;
+            }
+            switch (platform) {
+                case 'binance':
+                    if (!config.binance)
+                        return false;
+                    return cancelBinanceFuturesOrder(config.binance, symbol, orderId);
+                case 'bybit':
+                    if (!config.bybit)
+                        return false;
+                    return cancelBybitFuturesOrder(config.bybit, symbol, orderId);
+                case 'mexc':
+                    if (!config.mexc)
+                        return false;
+                    return cancelMexcFuturesOrder(config.mexc, symbol, orderId);
+                case 'hyperliquid':
+                    if (!config.hyperliquid)
+                        return false;
+                    return cancelHyperliquidOrder(config.hyperliquid, symbol, orderId);
+                default:
+                    logger_1.logger.warn({ platform }, 'Cancel not implemented for platform');
+                    return false;
+            }
+        },
+        async cancelAllOrders(platform, symbol) {
+            if (config.dryRun) {
+                logger_1.logger.info({ platform, symbol, dryRun: true }, 'Dry run cancel all');
+                return 0;
+            }
+            let count = 0;
+            if (platform === 'binance' || !platform) {
+                if (config.binance) {
+                    const orders = await getBinanceFuturesOpenOrders(config.binance, symbol);
+                    for (const order of orders) {
+                        if (await cancelBinanceFuturesOrder(config.binance, order.symbol, order.orderId)) {
+                            count++;
+                        }
+                    }
+                }
+            }
+            if (platform === 'bybit' || !platform) {
+                if (config.bybit) {
+                    const orders = await getBybitFuturesOpenOrders(config.bybit, symbol);
+                    for (const order of orders) {
+                        if (await cancelBybitFuturesOrder(config.bybit, order.symbol, order.orderId)) {
+                            count++;
+                        }
+                    }
+                }
+            }
+            if (platform === 'mexc' || !platform) {
+                if (config.mexc) {
+                    const orders = await getMexcFuturesOpenOrders(config.mexc, symbol);
+                    for (const order of orders) {
+                        if (await cancelMexcFuturesOrder(config.mexc, order.symbol, order.orderId)) {
+                            count++;
+                        }
+                    }
+                }
+            }
+            if (platform === 'hyperliquid' || !platform) {
+                if (config.hyperliquid) {
+                    const orders = await getHyperliquidOpenOrders(config.hyperliquid, symbol);
+                    for (const order of orders) {
+                        if (await cancelHyperliquidOrder(config.hyperliquid, order.symbol, order.orderId)) {
+                            count++;
+                        }
+                    }
+                }
+            }
+            return count;
+        },
+        async getOpenOrders(platform, symbol) {
+            const orders = [];
+            if ((!platform || platform === 'binance') && config.binance) {
+                orders.push(...await getBinanceFuturesOpenOrders(config.binance, symbol));
+            }
+            if ((!platform || platform === 'bybit') && config.bybit) {
+                orders.push(...await getBybitFuturesOpenOrders(config.bybit, symbol));
+            }
+            if ((!platform || platform === 'mexc') && config.mexc) {
+                orders.push(...await getMexcFuturesOpenOrders(config.mexc, symbol));
+            }
+            if ((!platform || platform === 'hyperliquid') && config.hyperliquid) {
+                orders.push(...await getHyperliquidOpenOrders(config.hyperliquid, symbol));
+            }
+            return orders;
+        },
+        async getPositions(platform, symbol) {
+            const positions = [];
+            if ((!platform || platform === 'binance') && config.binance) {
+                positions.push(...await getBinanceFuturesPositions(config.binance, symbol));
+            }
+            if ((!platform || platform === 'bybit') && config.bybit) {
+                positions.push(...await getBybitFuturesPositions(config.bybit, symbol));
+            }
+            if ((!platform || platform === 'mexc') && config.mexc) {
+                positions.push(...await getMexcFuturesPositions(config.mexc, symbol));
+            }
+            if ((!platform || platform === 'hyperliquid') && config.hyperliquid) {
+                positions.push(...await getHyperliquidPositions(config.hyperliquid, symbol));
+            }
+            return positions;
+        },
+        async getBalance(platform) {
+            const balances = [];
+            if ((!platform || platform === 'binance') && config.binance) {
+                balances.push(...await getBinanceFuturesBalance(config.binance));
+            }
+            if ((!platform || platform === 'bybit') && config.bybit) {
+                balances.push(...await getBybitFuturesBalance(config.bybit));
+            }
+            if ((!platform || platform === 'mexc') && config.mexc) {
+                balances.push(...await getMexcFuturesBalance(config.mexc));
+            }
+            if ((!platform || platform === 'hyperliquid') && config.hyperliquid) {
+                balances.push(...await getHyperliquidBalance(config.hyperliquid));
+            }
+            return balances;
+        },
+        async getFundingRate(platform, symbol) {
+            switch (platform) {
+                case 'binance':
+                    if (!config.binance)
+                        return null;
+                    return getBinanceFundingRate(config.binance, symbol);
+                case 'bybit':
+                    if (!config.bybit)
+                        return null;
+                    return getBybitFundingRate(config.bybit, symbol);
+                case 'mexc':
+                    if (!config.mexc)
+                        return null;
+                    return getMexcFundingRate(config.mexc, symbol);
+                case 'hyperliquid':
+                    return getHyperliquidFundingRate(symbol);
+                default:
+                    return null;
+            }
+        },
+        async setLeverage(platform, symbol, leverage) {
+            if (config.dryRun) {
+                logger_1.logger.info({ platform, symbol, leverage, dryRun: true }, 'Dry run set leverage');
+                return true;
+            }
+            switch (platform) {
+                case 'binance':
+                    if (!config.binance)
+                        return false;
+                    return setBinanceLeverage(config.binance, symbol, leverage);
+                case 'bybit':
+                    if (!config.bybit)
+                        return false;
+                    return setBybitLeverage(config.bybit, symbol, leverage);
+                case 'mexc':
+                    if (!config.mexc)
+                        return false;
+                    return setMexcLeverage(config.mexc, symbol, leverage);
+                case 'hyperliquid':
+                    if (!config.hyperliquid)
+                        return false;
+                    return setHyperliquidLeverage(config.hyperliquid, symbol, leverage);
+                default:
+                    logger_1.logger.warn({ platform }, 'Set leverage not implemented for platform');
+                    return false;
+            }
+        },
+        async setMarginType(platform, symbol, marginType) {
+            if (config.dryRun) {
+                logger_1.logger.info({ platform, symbol, marginType, dryRun: true }, 'Dry run set margin type');
+                return true;
+            }
+            switch (platform) {
+                case 'binance':
+                    if (!config.binance)
+                        return false;
+                    return setBinanceMarginType(config.binance, symbol, marginType);
+                case 'bybit':
+                    // Bybit unified account doesn't have separate margin type setting
+                    logger_1.logger.info({ symbol, marginType }, 'Bybit unified account - margin type set via leverage');
+                    return true;
+                case 'mexc':
+                    // MEXC sets margin type via openType in order (1=isolated, 2=cross)
+                    mexcMarginPreference.set(symbol, marginType);
+                    logger_1.logger.info({ symbol, marginType }, 'MEXC margin type preference saved (applied per-order)');
+                    return true;
+                case 'hyperliquid':
+                    if (!config.hyperliquid)
+                        return false;
+                    return setHyperliquidMarginType(config.hyperliquid, symbol, marginType);
+                default:
+                    logger_1.logger.warn({ platform }, 'Set margin type not implemented for platform');
+                    return false;
+            }
+        },
+        async getIncomeHistory(platform, params) {
+            switch (platform) {
+                case 'binance':
+                    if (!config.binance)
+                        return [];
+                    return getBinanceIncomeHistory(config.binance, params);
+                case 'bybit':
+                    if (!config.bybit)
+                        return [];
+                    return getBybitIncomeHistory(config.bybit, params);
+                case 'mexc':
+                    if (!config.mexc)
+                        return [];
+                    return getMexcIncomeHistory(config.mexc, params);
+                case 'hyperliquid':
+                    if (!config.hyperliquid)
+                        return [];
+                    return getHyperliquidIncomeHistory(config.hyperliquid, params);
+                default:
+                    return [];
+            }
+        },
+        calculateLiquidationPrice(params) {
+            // Simplified liquidation price calculation
+            // Real calculation is more complex and varies by exchange
+            const { side, entryPrice, leverage } = params;
+            // Maintenance margin rate (simplified - typically 0.4% for BTC on Binance)
+            const mmr = 0.004;
+            if (side === 'long') {
+                // Liq price for long = Entry * (1 - 1/leverage + mmr)
+                return entryPrice * (1 - 1 / leverage + mmr);
+            }
+            else {
+                // Liq price for short = Entry * (1 + 1/leverage - mmr)
+                return entryPrice * (1 + 1 / leverage - mmr);
+            }
+        },
+    };
+    logger_1.logger.info({
+        binance: !!config.binance,
+        bybit: !!config.bybit,
+        mexc: !!config.mexc,
+        hyperliquid: !!config.hyperliquid,
+        dryRun: !!config.dryRun,
+    }, 'Futures Execution Service initialized');
+    return service;
+}
+//# sourceMappingURL=futures.js.map