clodds 1.1.0

package/dist/trading/futures/index.d.ts

@@ -0,0 +1,981 @@
+/**
+ * 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
+ */
+import { EventEmitter } from 'events';
+export type FuturesExchange = 'binance' | 'bybit' | 'hyperliquid' | 'mexc';
+export type OrderSide = 'BUY' | 'SELL';
+export type PositionSide = 'LONG' | 'SHORT';
+export type OrderType = 'MARKET' | 'LIMIT' | 'STOP_MARKET' | 'TAKE_PROFIT_MARKET';
+export type MarginType = 'ISOLATED' | 'CROSS';
+export interface FuturesCredentials {
+    apiKey: string;
+    apiSecret: string;
+    passphrase?: string;
+    testnet?: boolean;
+}
+export interface FuturesPosition {
+    exchange: FuturesExchange;
+    symbol: string;
+    side: PositionSide;
+    size: number;
+    entryPrice: number;
+    markPrice: number;
+    liquidationPrice: number;
+    leverage: number;
+    marginType: MarginType;
+    unrealizedPnl: number;
+    unrealizedPnlPct: number;
+    margin: number;
+    timestamp: number;
+}
+export interface FuturesOrder {
+    id: string;
+    exchange: FuturesExchange;
+    symbol: string;
+    side: OrderSide;
+    type: OrderType;
+    size: number;
+    price?: number;
+    stopPrice?: number;
+    leverage: number;
+    reduceOnly: boolean;
+    status: 'NEW' | 'FILLED' | 'PARTIALLY_FILLED' | 'CANCELED' | 'REJECTED';
+    filledSize: number;
+    avgFillPrice: number;
+    timestamp: number;
+}
+export interface FuturesOrderRequest {
+    symbol: string;
+    side: OrderSide;
+    type: OrderType;
+    size: number;
+    price?: number;
+    stopPrice?: number;
+    leverage?: number;
+    reduceOnly?: boolean;
+    takeProfit?: number;
+    stopLoss?: number;
+}
+export interface FuturesBalance {
+    exchange: FuturesExchange;
+    asset: string;
+    available: number;
+    total: number;
+    unrealizedPnl: number;
+    marginBalance: number;
+}
+export interface FuturesMarket {
+    exchange: FuturesExchange;
+    symbol: string;
+    baseAsset: string;
+    quoteAsset: string;
+    tickSize: number;
+    lotSize: number;
+    minNotional: number;
+    maxLeverage: number;
+    fundingRate: number;
+    markPrice: number;
+    indexPrice: number;
+    volume24h: number;
+}
+export interface FuturesTrade {
+    id: string;
+    exchange: FuturesExchange;
+    symbol: string;
+    orderId: string;
+    side: OrderSide;
+    price: number;
+    quantity: number;
+    realizedPnl: number;
+    commission: number;
+    commissionAsset: string;
+    timestamp: number;
+    isMaker: boolean;
+}
+export interface FuturesKline {
+    openTime: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+    closeTime: number;
+    quoteVolume: number;
+    trades: number;
+    takerBuyVolume: number;
+    takerBuyQuoteVolume: number;
+}
+export interface FuturesOrderBook {
+    exchange: FuturesExchange;
+    symbol: string;
+    lastUpdateId: number;
+    bids: Array<[number, number]>;
+    asks: Array<[number, number]>;
+    timestamp: number;
+}
+export interface FuturesIncome {
+    symbol: string;
+    incomeType: 'REALIZED_PNL' | 'FUNDING_FEE' | 'COMMISSION' | 'TRANSFER' | 'OTHER';
+    income: number;
+    asset: string;
+    timestamp: number;
+    tradeId?: string;
+}
+export interface FuturesLeverageBracket {
+    symbol: string;
+    brackets: Array<{
+        bracket: number;
+        initialLeverage: number;
+        notionalCap: number;
+        notionalFloor: number;
+        maintMarginRatio: number;
+    }>;
+}
+export interface FuturesAccountInfo {
+    exchange: FuturesExchange;
+    totalWalletBalance: number;
+    totalUnrealizedProfit: number;
+    totalMarginBalance: number;
+    totalPositionInitialMargin: number;
+    totalOpenOrderInitialMargin: number;
+    availableBalance: number;
+    maxWithdrawAmount: number;
+    canTrade: boolean;
+    canDeposit: boolean;
+    canWithdraw: boolean;
+    positions: FuturesPosition[];
+}
+export interface FuturesRiskLimit {
+    symbol: string;
+    maxLeverage: number;
+    maintenanceMarginRate: number;
+    riskLimitValue: number;
+}
+export interface FuturesFundingHistory {
+    symbol: string;
+    fundingRate: number;
+    fundingTime: number;
+    markPrice?: number;
+}
+export type KlineInterval = '1m' | '3m' | '5m' | '15m' | '30m' | '1h' | '2h' | '4h' | '6h' | '8h' | '12h' | '1d' | '3d' | '1w' | '1M';
+export interface FuturesConfig {
+    exchange: FuturesExchange;
+    credentials: FuturesCredentials;
+    defaultLeverage?: number;
+    defaultMarginType?: MarginType;
+    maxPositionSize?: number;
+    maxLeverage?: number;
+    dryRun?: boolean;
+}
+export interface DatabaseConfig {
+    connectionString?: string;
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+}
+export interface FuturesTradeRecord {
+    id?: number;
+    exchange: FuturesExchange;
+    symbol: string;
+    side: PositionSide;
+    entryPrice: number;
+    exitPrice?: number;
+    size: number;
+    leverage: number;
+    entryTime: Date;
+    exitTime?: Date;
+    pnl?: number;
+    pnlPct?: number;
+    fees?: number;
+    strategy?: string;
+    strategyVariant?: string;
+    variables?: Record<string, number | string | boolean>;
+    tags?: string[];
+    notes?: string;
+}
+export interface FuturesStrategy {
+    name: string;
+    version: string;
+    description?: string;
+    variables: StrategyVariable[];
+    entryCondition: (market: FuturesMarket, variables: Record<string, number>) => Promise<'LONG' | 'SHORT' | null>;
+    exitCondition?: (position: FuturesPosition, variables: Record<string, number>) => Promise<boolean>;
+    calculateSize?: (balance: FuturesBalance, market: FuturesMarket, variables: Record<string, number>) => number;
+    calculateLeverage?: (market: FuturesMarket, variables: Record<string, number>) => number;
+}
+export interface StrategyVariable {
+    name: string;
+    type: 'number' | 'string' | 'boolean';
+    default: number | string | boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    description?: string;
+}
+export interface StrategyVariant {
+    strategyName: string;
+    variantName: string;
+    variables: Record<string, number | string | boolean>;
+    enabled: boolean;
+}
+export interface StrategyPerformance {
+    strategyName: string;
+    variantName?: string;
+    totalTrades: number;
+    winningTrades: number;
+    losingTrades: number;
+    winRate: number;
+    totalPnl: number;
+    avgPnl: number;
+    avgPnlPct: number;
+    maxDrawdown: number;
+    sharpeRatio?: number;
+    profitFactor?: number;
+    avgHoldingTime?: number;
+}
+declare class BinanceFuturesClient {
+    private apiKey;
+    private apiSecret;
+    private baseUrl;
+    private dryRun;
+    constructor(credentials: FuturesCredentials, dryRun?: boolean);
+    private sign;
+    private request;
+    getBalance(): Promise<FuturesBalance>;
+    getPositions(): Promise<FuturesPosition[]>;
+    setLeverage(symbol: string, leverage: number): Promise<void>;
+    setMarginType(symbol: string, marginType: MarginType): Promise<void>;
+    placeOrder(order: FuturesOrderRequest): Promise<FuturesOrder>;
+    private createDryRunOrder;
+    cancelOrder(symbol: string, orderId: string): Promise<void>;
+    closePosition(symbol: string): Promise<FuturesOrder | null>;
+    getMarkets(): Promise<FuturesMarket[]>;
+    getFundingRate(symbol: string): Promise<{
+        rate: number;
+        nextFundingTime: number;
+    }>;
+    getOpenOrders(symbol?: string): Promise<FuturesOrder[]>;
+    getAccountInfo(): Promise<FuturesAccountInfo>;
+    getTradeHistory(symbol: string, limit?: number): Promise<FuturesTrade[]>;
+    getOrderHistory(symbol?: string, limit?: number): Promise<FuturesOrder[]>;
+    getKlines(symbol: string, interval: KlineInterval, limit?: number): Promise<FuturesKline[]>;
+    getOrderBook(symbol: string, limit?: number): Promise<FuturesOrderBook>;
+    getIncomeHistory(symbol?: string, incomeType?: string, limit?: number): Promise<FuturesIncome[]>;
+    getLeverageBrackets(symbol?: string): Promise<FuturesLeverageBracket[]>;
+    getPositionMarginHistory(symbol: string, limit?: number): Promise<Array<{
+        symbol: string;
+        type: number;
+        amount: number;
+        asset: string;
+        timestamp: number;
+        positionSide: string;
+    }>>;
+    modifyPositionMargin(symbol: string, amount: number, type: 1 | 2): Promise<void>;
+    placeBatchOrders(orders: FuturesOrderRequest[]): Promise<FuturesOrder[]>;
+    cancelAllOrders(symbol: string): Promise<void>;
+    getTickerPrice(symbol?: string): Promise<Array<{
+        symbol: string;
+        price: number;
+        timestamp: number;
+    }>>;
+    getFundingHistory(symbol: string, limit?: number): Promise<FuturesFundingHistory[]>;
+    setPositionMode(dualSidePosition: boolean): Promise<void>;
+    getPositionMode(): Promise<boolean>;
+    modifyOrder(symbol: string, orderId: string, quantity?: number, price?: number): Promise<FuturesOrder>;
+    getForceOrders(symbol?: string, limit?: number): Promise<Array<{
+        orderId: string;
+        symbol: string;
+        side: OrderSide;
+        price: number;
+        quantity: number;
+        status: string;
+        timestamp: number;
+    }>>;
+    getCommissionRate(symbol: string): Promise<{
+        symbol: string;
+        makerCommission: number;
+        takerCommission: number;
+    }>;
+    createListenKey(): Promise<string>;
+    keepAliveListenKey(): Promise<void>;
+    deleteListenKey(): Promise<void>;
+    getServerTime(): Promise<number>;
+    ping(): Promise<boolean>;
+    getExchangeInfo(): Promise<{
+        symbols: Array<{
+            symbol: string;
+            status: string;
+            baseAsset: string;
+            quoteAsset: string;
+            pricePrecision: number;
+            quantityPrecision: number;
+            contractType: string;
+        }>;
+    }>;
+    getRecentTrades(symbol: string, limit?: number): Promise<Array<{
+        id: number;
+        price: number;
+        qty: number;
+        quoteQty: number;
+        time: number;
+        isBuyerMaker: boolean;
+    }>>;
+    getAggTrades(symbol: string, limit?: number): Promise<Array<{
+        aggTradeId: number;
+        price: number;
+        quantity: number;
+        firstTradeId: number;
+        lastTradeId: number;
+        timestamp: number;
+        isBuyerMaker: boolean;
+    }>>;
+    getContinuousKlines(pair: string, contractType: 'PERPETUAL' | 'CURRENT_QUARTER' | 'NEXT_QUARTER', interval: KlineInterval, limit?: number): Promise<FuturesKline[]>;
+    getIndexPriceKlines(pair: string, interval: KlineInterval, limit?: number): Promise<FuturesKline[]>;
+    getMarkPriceKlines(symbol: string, interval: KlineInterval, limit?: number): Promise<FuturesKline[]>;
+    get24hrTicker(symbol?: string): Promise<Array<{
+        symbol: string;
+        priceChange: number;
+        priceChangePercent: number;
+        weightedAvgPrice: number;
+        lastPrice: number;
+        lastQty: number;
+        openPrice: number;
+        highPrice: number;
+        lowPrice: number;
+        volume: number;
+        quoteVolume: number;
+        openTime: number;
+        closeTime: number;
+        count: number;
+    }>>;
+    getBookTicker(symbol?: string): Promise<Array<{
+        symbol: string;
+        bidPrice: number;
+        bidQty: number;
+        askPrice: number;
+        askQty: number;
+        time: number;
+    }>>;
+    getOpenInterest(symbol: string): Promise<{
+        symbol: string;
+        openInterest: number;
+        time: number;
+    }>;
+    getOpenInterestHistory(symbol: string, period: '5m' | '15m' | '30m' | '1h' | '2h' | '4h' | '6h' | '12h' | '1d', limit?: number): Promise<Array<{
+        symbol: string;
+        sumOpenInterest: number;
+        sumOpenInterestValue: number;
+        timestamp: number;
+    }>>;
+    getTopTraderLongShortRatio(symbol: string, period: '5m' | '15m' | '30m' | '1h' | '2h' | '4h' | '6h' | '12h' | '1d', limit?: number): Promise<Array<{
+        symbol: string;
+        longShortRatio: number;
+        longAccount: number;
+        shortAccount: number;
+        timestamp: number;
+    }>>;
+    getGlobalLongShortRatio(symbol: string, period: '5m' | '15m' | '30m' | '1h' | '2h' | '4h' | '6h' | '12h' | '1d', limit?: number): Promise<Array<{
+        symbol: string;
+        longShortRatio: number;
+        longAccount: number;
+        shortAccount: number;
+        timestamp: number;
+    }>>;
+    getTakerBuySellVolume(symbol: string, period: '5m' | '15m' | '30m' | '1h' | '2h' | '4h' | '6h' | '12h' | '1d', limit?: number): Promise<Array<{
+        buySellRatio: number;
+        buyVol: number;
+        sellVol: number;
+        timestamp: number;
+    }>>;
+    getFundingInfo(): Promise<Array<{
+        symbol: string;
+        adjustedFundingRateCap: number;
+        adjustedFundingRateFloor: number;
+        fundingIntervalHours: number;
+    }>>;
+    getADLQuantile(symbol?: string): Promise<Array<{
+        symbol: string;
+        adlQuantile: {
+            LONG: number;
+            SHORT: number;
+            BOTH: number;
+        };
+    }>>;
+    setMultiAssetsMode(multiAssetsMargin: boolean): Promise<void>;
+    getMultiAssetsMode(): Promise<boolean>;
+    testOrder(order: FuturesOrderRequest): Promise<void>;
+    setAutoCancel(symbol: string, countdownTime: number): Promise<{
+        symbol: string;
+        countdownTime: number;
+    }>;
+    getOrderModifyHistory(symbol: string, orderId?: string, limit?: number): Promise<Array<{
+        symbol: string;
+        orderId: number;
+        amendmentId: number;
+        time: number;
+        amendment: {
+            price: {
+                before: number;
+                after: number;
+            };
+            origQty: {
+                before: number;
+                after: number;
+            };
+        };
+    }>>;
+    getSymbolConfig(symbol?: string): Promise<Array<{
+        symbol: string;
+        marginType: string;
+        isAutoAddMargin: boolean;
+        leverage: number;
+        maxNotionalValue: number;
+    }>>;
+    getOrderRateLimit(): Promise<Array<{
+        rateLimitType: string;
+        interval: string;
+        intervalNum: number;
+        limit: number;
+    }>>;
+}
+declare class BybitFuturesClient {
+    private apiKey;
+    private apiSecret;
+    private baseUrl;
+    private dryRun;
+    private recvWindow;
+    constructor(credentials: FuturesCredentials, dryRun?: boolean);
+    private sign;
+    private request;
+    getBalance(): Promise<FuturesBalance>;
+    getPositions(): Promise<FuturesPosition[]>;
+    setLeverage(symbol: string, leverage: number): Promise<void>;
+    placeOrder(order: FuturesOrderRequest): Promise<FuturesOrder>;
+    private createDryRunOrder;
+    cancelOrder(symbol: string, orderId: string): Promise<void>;
+    closePosition(symbol: string): Promise<FuturesOrder | null>;
+    getMarkets(): Promise<FuturesMarket[]>;
+    getFundingRate(symbol: string): Promise<{
+        rate: number;
+        nextFundingTime: number;
+    }>;
+    getOpenOrders(symbol?: string): Promise<FuturesOrder[]>;
+    private mapBybitStatus;
+    getAccountInfo(): Promise<FuturesAccountInfo>;
+    getTradeHistory(symbol?: string, limit?: number): Promise<FuturesTrade[]>;
+    getOrderHistory(symbol?: string, limit?: number): Promise<FuturesOrder[]>;
+    getKlines(symbol: string, interval: string, limit?: number): Promise<FuturesKline[]>;
+    getOrderBook(symbol: string, limit?: number): Promise<FuturesOrderBook>;
+    getIncomeHistory(symbol?: string, limit?: number): Promise<FuturesIncome[]>;
+    getRiskLimit(symbol: string): Promise<FuturesRiskLimit[]>;
+    setRiskLimit(symbol: string, riskId: number): Promise<void>;
+    amendOrder(symbol: string, orderId: string, qty?: number, price?: number): Promise<FuturesOrder>;
+    cancelAllOrders(symbol?: string): Promise<void>;
+    placeBatchOrders(orders: FuturesOrderRequest[]): Promise<FuturesOrder[]>;
+    getTickerPrice(symbol?: string): Promise<Array<{
+        symbol: string;
+        price: number;
+        timestamp: number;
+    }>>;
+    getFundingHistory(symbol: string, limit?: number): Promise<FuturesFundingHistory[]>;
+    setPositionMode(mode: 'MergedSingle' | 'BothSide'): Promise<void>;
+    setIsolatedMargin(symbol: string, tradeMode: 0 | 1, leverage?: number): Promise<void>;
+    modifyPositionMargin(symbol: string, margin: number): Promise<void>;
+    getRecentTrades(symbol: string, limit?: number): Promise<Array<{
+        price: number;
+        size: number;
+        side: string;
+        timestamp: number;
+    }>>;
+    getServerTime(): Promise<number>;
+    batchAmendOrders(orders: Array<{
+        symbol: string;
+        orderId: string;
+        qty?: number;
+        price?: number;
+    }>): Promise<Array<{
+        orderId: string;
+        success: boolean;
+    }>>;
+    batchCancelOrders(orders: Array<{
+        symbol: string;
+        orderId: string;
+    }>): Promise<Array<{
+        orderId: string;
+        success: boolean;
+    }>>;
+    setDisconnectProtection(expiryTime: number): Promise<void>;
+    getSpotBorrowQuota(symbol: string, side: 'Buy' | 'Sell'): Promise<{
+        symbol: string;
+        maxTradeQty: number;
+        side: string;
+        borrowCoin: string;
+    }>;
+    getOpenInterest(symbol: string, interval: '5min' | '15min' | '30min' | '1h' | '4h' | '1d', limit?: number): Promise<Array<{
+        openInterest: number;
+        timestamp: number;
+    }>>;
+    getLongShortRatio(symbol: string, period: '5min' | '15min' | '30min' | '1h' | '4h' | '1d', limit?: number): Promise<Array<{
+        buyRatio: number;
+        sellRatio: number;
+        timestamp: number;
+    }>>;
+    getInsurance(coin?: string): Promise<Array<{
+        coin: string;
+        balance: number;
+        value: number;
+    }>>;
+    getVolatility(category: 'option', baseCoin?: string, period?: number): Promise<Array<{
+        period: number;
+        value: number;
+        time: number;
+    }>>;
+    getDeliveryPrice(symbol: string, limit?: number): Promise<Array<{
+        symbol: string;
+        deliveryPrice: number;
+        deliveryTime: number;
+    }>>;
+    getPreListingInfo(symbol?: string): Promise<Array<{
+        symbol: string;
+        auctionPhaseType: string;
+        auctionFeeInfo: {
+            auctionFeeRate: number;
+            takerFeeRate: number;
+            makerFeeRate: number;
+        };
+    }>>;
+    setTradingStop(symbol: string, takeProfit?: number, stopLoss?: number, trailingStop?: number, positionIdx?: 0 | 1 | 2): Promise<void>;
+    getClosedPnL(symbol?: string, limit?: number): Promise<Array<{
+        symbol: string;
+        orderId: string;
+        side: string;
+        qty: number;
+        orderPrice: number;
+        closedPnl: number;
+        createdTime: number;
+    }>>;
+    movePosition(fromUid: string, toUid: string, symbol: string, side: 'Buy' | 'Sell', price: number, qty: number): Promise<{
+        blockTradeId: string;
+        status: string;
+    }>;
+    confirmNewRiskLimit(symbol: string): Promise<void>;
+    getFeeRate(symbol?: string): Promise<Array<{
+        symbol: string;
+        takerFeeRate: number;
+        makerFeeRate: number;
+    }>>;
+    getAccountInfo2(): Promise<{
+        unifiedMarginStatus: number;
+        marginMode: string;
+        dcpStatus: string;
+        timeWindow: number;
+        smpGroup: number;
+    }>;
+    getTransactionLog(accountType?: 'UNIFIED' | 'CONTRACT', category?: 'linear' | 'spot', currency?: string, limit?: number): Promise<Array<{
+        symbol: string;
+        side: string;
+        funding: number;
+        orderLinkId: string;
+        orderId: string;
+        fee: number;
+        change: number;
+        cashFlow: number;
+        transactionTime: number;
+        type: string;
+    }>>;
+}
+declare class HyperliquidClient {
+    private walletAddress;
+    private privateKey;
+    private baseUrl;
+    private dryRun;
+    private assetIndexMap;
+    constructor(credentials: FuturesCredentials, dryRun?: boolean);
+    private request;
+    private ensureAssetIndex;
+    private getAssetIndex;
+    private signL1Action;
+    getBalance(): Promise<FuturesBalance>;
+    getPositions(): Promise<FuturesPosition[]>;
+    placeOrder(order: FuturesOrderRequest): Promise<FuturesOrder>;
+    private createDryRunOrder;
+    cancelOrder(symbol: string, orderId: string): Promise<void>;
+    closePosition(symbol: string): Promise<FuturesOrder | null>;
+    getMarkets(): Promise<FuturesMarket[]>;
+    getFundingRate(symbol: string): Promise<{
+        rate: number;
+        nextFundingTime: number;
+    }>;
+    setLeverage(symbol: string, leverage: number, marginType?: MarginType): Promise<void>;
+    getOpenOrders(symbol?: string): Promise<FuturesOrder[]>;
+    getAccountInfo(): Promise<FuturesAccountInfo>;
+    getTradeHistory(limit?: number): Promise<FuturesTrade[]>;
+    getOrderHistory(): Promise<FuturesOrder[]>;
+    getOrderBook(symbol: string): Promise<FuturesOrderBook>;
+    getKlines(symbol: string, interval: string, startTime?: number, endTime?: number): Promise<FuturesKline[]>;
+    getUserFees(): Promise<{
+        maker: number;
+        taker: number;
+    }>;
+    getRateLimit(): Promise<{
+        used: number;
+        limit: number;
+    }>;
+    getOrderStatus(orderId: number): Promise<{
+        status: string;
+        filled: number;
+    }>;
+    cancelByClientOrderId(symbol: string, cloid: string): Promise<void>;
+    modifyOrder(symbol: string, orderId: number, price: number, size: number, isBuy: boolean): Promise<FuturesOrder>;
+    updateIsolatedMargin(symbol: string, marginDelta: number): Promise<void>;
+    transferUsd(amount: number, toPerp: boolean): Promise<void>;
+    getSubAccounts(): Promise<Array<{
+        name: string;
+        subAccountUser: string;
+        master: string;
+    }>>;
+    placeTwapOrder(symbol: string, isBuy: boolean, size: number, durationMinutes: number, randomize?: boolean): Promise<{
+        status: string;
+        twapId?: number;
+    }>;
+    cancelTwapOrder(symbol: string, twapId: number): Promise<void>;
+    getMeta(): Promise<{
+        universe: Array<{
+            name: string;
+            szDecimals: number;
+            maxLeverage: number;
+        }>;
+    }>;
+    scheduleCancel(time: number | null): Promise<void>;
+    sendUsd(destination: string, amount: number): Promise<void>;
+    sendSpot(destination: string, token: string, amount: number): Promise<void>;
+    withdraw(destination: string, amount: number): Promise<void>;
+    transferBetweenSpotAndPerp(amount: number, toPerp: boolean): Promise<void>;
+    vaultTransfer(vaultAddress: string, amount: number, isDeposit: boolean): Promise<void>;
+    approveAgent(agentAddress: string, agentName?: string): Promise<void>;
+    approveBuilderFee(builder: string, maxFeeRate: number): Promise<void>;
+    setReferrer(code: string): Promise<void>;
+    stakeDeposit(amount: number): Promise<void>;
+    stakeWithdraw(amount: number): Promise<void>;
+    delegateTokens(validator: string, amount: number, undelegate: boolean): Promise<void>;
+    getVaultDetails(vaultAddress: string): Promise<{
+        name: string;
+        vaultAddress: string;
+        leader: string;
+        tvl: number;
+        totalPnl: number;
+    }>;
+    getUserVaultEquities(): Promise<Array<{
+        vaultAddress: string;
+        equity: number;
+    }>>;
+    getUserRole(): Promise<{
+        role: string;
+    }>;
+    getPortfolio(): Promise<Array<{
+        name: string;
+        allTimePnl: number;
+        dailyPnl: number;
+        monthlyPnl: number;
+    }>>;
+    getReferralInfo(): Promise<{
+        referredBy?: string;
+        cumVlm: number;
+        unclaimedRewards: number;
+        claimedRewards: number;
+    }>;
+    getStakingDelegations(): Promise<Array<{
+        validator: string;
+        amount: number;
+        lockedUntil?: number;
+    }>>;
+    getStakingSummary(): Promise<{
+        delegated: number;
+        undelegating: number;
+        claimable: number;
+        totalRewards: number;
+    }>;
+    getStakingRewards(limit?: number): Promise<Array<{
+        validator: string;
+        amount: number;
+        timestamp: number;
+    }>>;
+    getBorrowLendState(): Promise<{
+        borrowed: number;
+        lent: number;
+        borrowApy: number;
+        lendApy: number;
+    }>;
+    getAllBorrowLendReserves(): Promise<Array<{
+        coin: string;
+        totalBorrowed: number;
+        totalLent: number;
+        borrowApy: number;
+        lendApy: number;
+    }>>;
+    getFrontendOpenOrders(): Promise<Array<{
+        coin: string;
+        oid: number;
+        side: string;
+        limitPx: number;
+        sz: number;
+        timestamp: number;
+        triggerCondition?: string;
+        isTrigger: boolean;
+        reduceOnly: boolean;
+    }>>;
+    getTwapSliceFills(): Promise<Array<{
+        coin: string;
+        px: number;
+        sz: number;
+        side: string;
+        time: number;
+        fee: number;
+        twapId: number;
+    }>>;
+    getMaxBuilderFee(builder: string): Promise<{
+        maxFeeRate: number;
+    }>;
+    getSpotMeta(): Promise<{
+        tokens: Array<{
+            name: string;
+            szDecimals: number;
+            weiDecimals: number;
+            index: number;
+        }>;
+        universe: Array<{
+            name: string;
+            tokens: number[];
+            index: number;
+        }>;
+    }>;
+    getSpotClearinghouseState(): Promise<{
+        balances: Array<{
+            coin: string;
+            hold: number;
+            total: number;
+        }>;
+    }>;
+}
+declare class MexcFuturesClient {
+    private apiKey;
+    private apiSecret;
+    private baseUrl;
+    private dryRun;
+    private _marginType;
+    constructor(credentials: FuturesCredentials, dryRun?: boolean);
+    setMarginTypePreference(marginType: MarginType): void;
+    private sign;
+    private request;
+    getBalance(): Promise<FuturesBalance>;
+    getPositions(): Promise<FuturesPosition[]>;
+    setLeverage(symbol: string, leverage: number): Promise<void>;
+    placeOrder(order: FuturesOrderRequest): Promise<FuturesOrder>;
+    private createDryRunOrder;
+    cancelOrder(symbol: string, orderId: string): Promise<void>;
+    closePosition(symbol: string): Promise<FuturesOrder | null>;
+    getMarkets(): Promise<FuturesMarket[]>;
+    getFundingRate(symbol: string): Promise<{
+        rate: number;
+        nextFundingTime: number;
+    }>;
+    getOpenOrders(symbol?: string): Promise<FuturesOrder[]>;
+    private mapMexcStatus;
+    getAccountInfo(): Promise<FuturesAccountInfo>;
+    getTradeHistory(symbol?: string, limit?: number): Promise<FuturesTrade[]>;
+    getOrderHistory(symbol?: string, limit?: number): Promise<FuturesOrder[]>;
+    getKlines(symbol: string, interval: string, limit?: number): Promise<FuturesKline[]>;
+    getOrderBook(symbol: string, limit?: number): Promise<FuturesOrderBook>;
+    getPositionHistory(symbol?: string, limit?: number): Promise<Array<{
+        symbol: string;
+        side: PositionSide;
+        entryPrice: number;
+        closePrice: number;
+        size: number;
+        realizedPnl: number;
+        openTime: number;
+        closeTime: number;
+    }>>;
+    getFundingHistory(symbol?: string, limit?: number): Promise<FuturesFundingHistory[]>;
+    modifyPositionMargin(symbol: string, amount: number, positionType: 1 | 2): Promise<void>;
+    getPositionMode(): Promise<'one_way' | 'hedge'>;
+    setPositionMode(hedgeMode: boolean): Promise<void>;
+    placeBatchOrders(orders: FuturesOrderRequest[]): Promise<FuturesOrder[]>;
+    cancelAllOrders(symbol: string): Promise<void>;
+    getTickerPrice(symbol?: string): Promise<Array<{
+        symbol: string;
+        price: number;
+        timestamp: number;
+    }>>;
+    getRecentTrades(symbol: string, limit?: number): Promise<Array<{
+        price: number;
+        size: number;
+        side: string;
+        timestamp: number;
+    }>>;
+    getRiskLimits(): Promise<FuturesRiskLimit[]>;
+    getTieredFeeRate(): Promise<{
+        makerFee: number;
+        takerFee: number;
+        level: number;
+    }>;
+    placeTriggerOrder(symbol: string, side: OrderSide, size: number, triggerPrice: number, triggerType: 'ge' | 'le', price?: number): Promise<string>;
+    cancelTriggerOrder(symbol: string, orderId: string): Promise<void>;
+    cancelAllTriggerOrders(symbol: string): Promise<void>;
+    getTriggerOrders(symbol?: string): Promise<Array<{
+        orderId: string;
+        symbol: string;
+        side: OrderSide;
+        size: number;
+        triggerPrice: number;
+        status: string;
+    }>>;
+    getServerTime(): Promise<number>;
+}
+export declare class FuturesDatabase {
+    private pool;
+    private initialized;
+    connect(config: DatabaseConfig): Promise<void>;
+    initialize(): Promise<void>;
+    recordTrade(trade: FuturesTradeRecord): Promise<number>;
+    updateTrade(id: number, updates: Partial<FuturesTradeRecord>): Promise<void>;
+    getTrades(filters?: {
+        strategy?: string;
+        strategyVariant?: string;
+        exchange?: FuturesExchange;
+        symbol?: string;
+        startDate?: Date;
+        endDate?: Date;
+        limit?: number;
+    }): Promise<FuturesTradeRecord[]>;
+    getStrategyPerformance(strategyName: string, variantName?: string): Promise<StrategyPerformance>;
+    compareVariants(strategyName: string): Promise<StrategyPerformance[]>;
+    saveStrategyVariant(variant: StrategyVariant): Promise<void>;
+    getStrategyVariants(strategyName: string): Promise<StrategyVariant[]>;
+    disconnect(): Promise<void>;
+}
+export declare class StrategyEngine {
+    private strategies;
+    private variants;
+    private activePositions;
+    private db;
+    private service;
+    registerStrategy(strategy: FuturesStrategy): void;
+    addVariant(variant: StrategyVariant): void;
+    loadVariantsFromDb(db: FuturesDatabase): Promise<void>;
+    connectService(service: FuturesService): void;
+    getStrategies(): string[];
+    getVariants(strategyName: string): StrategyVariant[];
+    evaluateEntry(exchange: FuturesExchange, market: FuturesMarket, strategyName: string, variantName?: string): Promise<{
+        signal: 'LONG' | 'SHORT' | null;
+        variables: Record<string, number>;
+    }>;
+    executeTrade(exchange: FuturesExchange, symbol: string, signal: 'LONG' | 'SHORT', strategyName: string, variantName: string, variables: Record<string, number | string | boolean>): Promise<FuturesOrder | null>;
+    closeTrade(exchange: FuturesExchange, symbol: string, exitPrice: number): Promise<void>;
+    runABTest(exchange: FuturesExchange, symbol: string, strategyName: string, durationMinutes?: number): Promise<void>;
+}
+export declare class FuturesService extends EventEmitter {
+    private clients;
+    private config;
+    private positionMonitorInterval;
+    private db;
+    private strategyEngine;
+    private hlPrefs;
+    constructor(configs: FuturesConfig[]);
+    connectDatabase(config: DatabaseConfig): Promise<void>;
+    enableStrategies(): StrategyEngine;
+    getDatabase(): FuturesDatabase | null;
+    getStrategyEngine(): StrategyEngine | null;
+    private initClient;
+    private getClient;
+    getBalance(exchange: FuturesExchange): Promise<FuturesBalance>;
+    getAllBalances(): Promise<FuturesBalance[]>;
+    getPositions(exchange: FuturesExchange): Promise<FuturesPosition[]>;
+    getAllPositions(): Promise<FuturesPosition[]>;
+    placeOrder(exchange: FuturesExchange, order: FuturesOrderRequest): Promise<FuturesOrder>;
+    openLong(exchange: FuturesExchange, symbol: string, size: number, leverage: number, options?: {
+        price?: number;
+        takeProfit?: number;
+        stopLoss?: number;
+    }): Promise<FuturesOrder>;
+    openShort(exchange: FuturesExchange, symbol: string, size: number, leverage: number, options?: {
+        price?: number;
+        takeProfit?: number;
+        stopLoss?: number;
+    }): Promise<FuturesOrder>;
+    closePosition(exchange: FuturesExchange, symbol: string): Promise<FuturesOrder | null>;
+    closeAllPositions(exchange: FuturesExchange): Promise<FuturesOrder[]>;
+    cancelOrder(exchange: FuturesExchange, symbol: string, orderId: string): Promise<void>;
+    getMarkets(exchange: FuturesExchange): Promise<FuturesMarket[]>;
+    getFundingRate(exchange: FuturesExchange, symbol: string): Promise<{
+        rate: number;
+        nextFundingTime: number;
+    }>;
+    getOpenOrders(exchange: FuturesExchange, symbol?: string): Promise<FuturesOrder[]>;
+    startPositionMonitor(intervalMs?: number): void;
+    stopPositionMonitor(): void;
+    getExchanges(): FuturesExchange[];
+    setMarginType(exchange: FuturesExchange, symbol: string, marginType: MarginType): Promise<void>;
+    setLeverage(exchange: FuturesExchange, symbol: string, leverage: number): Promise<void>;
+    getIncomeHistory(exchange: FuturesExchange, params?: {
+        symbol?: string;
+        limit?: number;
+    }): Promise<FuturesIncome[]>;
+    getTradeHistory(exchange: FuturesExchange, symbol?: string, limit?: number): Promise<FuturesTrade[]>;
+    getOrderHistory(exchange: FuturesExchange, symbol?: string, limit?: number): Promise<FuturesOrder[]>;
+    getAccountInfo(exchange: FuturesExchange): Promise<FuturesAccountInfo>;
+    getOrderBook(exchange: FuturesExchange, symbol: string, limit?: number): Promise<FuturesOrderBook>;
+    getTickerPrice(exchange: FuturesExchange, symbol?: string): Promise<Array<{
+        symbol: string;
+        price: number;
+        timestamp: number;
+    }>>;
+}
+export declare function createFuturesService(configs: FuturesConfig[]): FuturesService;
+/**
+ * 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)
+ */
+export declare function setupFromEnv(): Promise<{
+    service: FuturesService;
+    db: FuturesDatabase | null;
+    strategies: StrategyEngine;
+}>;
+/**
+ * Simple momentum strategy
+ * Buys when funding is negative (shorts paying longs)
+ * Sells when funding is positive (longs paying shorts)
+ */
+export declare const MomentumStrategy: FuturesStrategy;
+/**
+ * Mean reversion strategy
+ * Buys oversold, sells overbought based on price deviation
+ */
+export declare const MeanReversionStrategy: FuturesStrategy;
+/**
+ * Grid trading strategy
+ * Places orders at regular price intervals
+ */
+export declare const GridStrategy: FuturesStrategy;
+export { BinanceFuturesClient, BybitFuturesClient, HyperliquidClient, MexcFuturesClient };