@metaflux/fluxaction 0.1.3 → 0.1.6

package/src/index.ts

@@ -1,138 +1,33 @@
-import type { ExchangeAdapter } from './core/exchange'
-import { RiskManager } from './core/RiskManager'
-import {
-  type TakeProfitOrder,
-  type StopLossOrder,
-  type TrailingStopOrder,
-} from './core/logicalOrders'
-import { GateSpotAdapter } from './exchanges/GateSpotAdapter'
-
-export interface FluxActionConfig {
-  okx?: {
-    apiKey: string
-    secret: string
-    passphrase: string
-    isDemo?: boolean
-  }
-  gate?: {
-    apiKey: string
-    secret: string
-  }
-  risk?: {
-    pollIntervalMs?: number
-  }
-}
-
-export class FluxAction {
-  private adapters: Record<string, ExchangeAdapter> = {}
-  private risk: RiskManager
-
-  constructor(cfg: FluxActionConfig) {
-    if (cfg.gate) {
-      const gate = new GateSpotAdapter({
-        id: 'gate-spot',
-        apiKey: cfg.gate.apiKey,
-        secret: cfg.gate.secret,
-      })
-      this.adapters[gate.id] = gate
-    }
-
-    this.risk = new RiskManager({
-      exchanges: this.adapters,
-      pollIntervalMs: cfg.risk?.pollIntervalMs,
-    })
-  }
-
-  async init(): Promise<void> {
-    await Promise.all(Object.values(this.adapters).map((a) => a.loadMarkets()))
-  }
-
-  getExchange(id: string): ExchangeAdapter | undefined {
-    return this.adapters[id]
-  }
-
-  async openSpotPosition(params: {
-    exchangeId: string
-    symbol: string
-    quoteCost: number
-  }): Promise<{ orderId: string; filledBase: number; avgPrice: number }> {
-    const ex = this.requireExchange(params.exchangeId)
-    const order = await ex.marketBuySpot(params.symbol, params.quoteCost)
-
-    return {
-        orderId: order.id,
-        filledBase: order.amount,       
-        avgPrice: order.price ?? 0,
-    }
-  }
-
-  async closeSpotMarket(params: {
-    exchangeId: string
-    symbol: string
-    baseQty: number
-  }): Promise<{ orderId: string }> {
-    const ex = this.requireExchange(params.exchangeId)
-    const order = await ex.marketSellSpot(params.symbol, params.baseQty)
-    return { orderId: order.id }
-  }
-
-  async placeSpotLimit(params: {
-    exchangeId: string
-    symbol: string
-    side: 'buy' | 'sell'
-    baseQty: number
-    price: number
-  }): Promise<{ orderId: string }> {
-    const ex = this.requireExchange(params.exchangeId)
-    const order = await ex.limitOrderSpot(
-      params.symbol,
-      params.side,
-      params.baseQty,
-      params.price,
-    )
-    return { orderId: order.id }
-  }
+export { FluxAction, type FluxActionConfig } from './FluxAction'
 
-  async placeTakeProfit(o: TakeProfitOrder): Promise<{ id: string }> {
-    await this.risk.placeTakeProfit(o)
-    return { id: o.id }
-  }
-
-  async placeStopLoss(o: StopLossOrder): Promise<{ id: string }> {
-    await this.risk.placeStopLoss(o)
-    return { id: o.id }
-  }
-
-  async placeTrailingStop(o: TrailingStopOrder): Promise<{ id: string }> {
-    await this.risk.placeTrailingStop(o)
-    return { id: o.id }
-  }
-
-  async cancelLogical(id: string): Promise<void> {
-    await this.risk.cancel(id)
-  }
-
-  getActiveLogicalOrders() {
-    return this.risk.getActiveOrders()
-  }
-
-  private requireExchange(id: string): ExchangeAdapter {
-    const ex = this.adapters[id]
-    if (!ex) throw new Error(`Exchange ${id} is not configured`)
-    return ex
-  }
-}
-
-export { RiskManager, type RiskManagerConfig } from './core/RiskManager'
 export type {
   ExchangeAdapter,
   ExchangeCapabilities,
   MarketInfo,
   OrderInfo,
   PositionInfo,
+  PositionSide,
+  MarketType,
+  Side,
 } from './core/exchange'
 
+export type { OrderKind, MarketOrLimit, SpotSide } from './core/orders'
+
+export type {
+  LogicalOrder,
+  TakeProfitOrder,
+  StopLossOrder,
+  TrailingStopOrder,
+  LogicalOrderKind,
+  MarketScope,
+  FuturesPositionSide,
+  ExitMode,
+} from './core/logicalOrders'
+
+export { GateClient } from './clients/GateClient'
 export {
   GateSpotAdapter,
   type GateSpotAdapterConfig,
-} from './exchanges/GateSpotAdapter'
+  GateFuturesAdapter,
+  type GateFuturesAdapterConfig,
+} from './exchanges/gate'

package/src/risk/ExitExecutor.ts

@@ -0,0 +1,56 @@
+import type { ExchangeAdapter } from '../core/exchange'
+import type { LogicalOrder } from '../core/logicalOrders'
+
+export class ExitExecutor {
+  async execute(ex: ExchangeAdapter, o: LogicalOrder, price: number): Promise<void> {
+    if (o.market === 'spot') {
+      await this.exitSpot(ex, o, price)
+      return
+    }
+    if (o.market === 'futures') {
+      await this.exitFutures(ex, o)
+      return
+    }
+    throw new Error(`Unknown market scope: ${(o as any).market}`)
+  }
+
+  private async exitSpot(ex: ExchangeAdapter, o: LogicalOrder, price: number) {
+    const side = o.side ?? 'sell'
+    const qty = o.qty ?? 0
+    if (qty <= 0) {
+      console.warn('[ExitExecutor] spot exit skipped: qty<=0', { id: o.id, symbol: o.symbol })
+      return
+    }
+
+    const bal = await ex.fetchBalance()
+    const base = o.symbol.split('/')[0]
+    const free = bal[base]?.free ?? 0
+    const rawQty = Math.min(qty, free * 0.995)
+
+    if (rawQty <= 0) {
+      console.warn('[ExitExecutor] spot exit skipped: no free base', { id: o.id, symbol: o.symbol, base, free, qty })
+      return
+    }
+
+    if (side === 'sell') {
+      await ex.marketSellSpot(o.symbol, rawQty)
+    } else {
+      const quoteCost = price * rawQty
+      await ex.marketBuySpot(o.symbol, quoteCost)
+    }
+  }
+
+  private async exitFutures(ex: ExchangeAdapter, o: LogicalOrder) {
+    const positionSide = o.positionSide
+    if (!positionSide) {
+      throw new Error(`[ExitExecutor] futures order missing positionSide: ${o.id}`)
+    }
+
+    const exitMode = o.exitMode ?? 'all'
+    await ex.closeFutures({
+      symbol: o.symbol,
+      side: positionSide,
+      closeMode: exitMode,
+    })
+  }
+}

package/src/risk/OrderStore.ts

@@ -0,0 +1,21 @@
+import type { LogicalOrder } from '../core/logicalOrders'
+
+export interface OrderStore {
+  set(o: LogicalOrder): void
+  delete(id: string): void
+  values(): LogicalOrder[]
+}
+
+export class InMemoryOrderStore implements OrderStore {
+  private orders = new Map<string, LogicalOrder>()
+
+  set(o: LogicalOrder) {
+    this.orders.set(o.id, o)
+  }
+  delete(id: string) {
+    this.orders.delete(id)
+  }
+  values(): LogicalOrder[] {
+    return [...this.orders.values()]
+  }
+}

package/src/risk/RiskEngine.ts

@@ -0,0 +1,101 @@
+import type { ExchangeAdapter } from '../core/exchange'
+import type { LogicalOrder, TakeProfitOrder, StopLossOrder, TrailingStopOrder } from '../core/logicalOrders'
+import type { OrderStore } from './OrderStore'
+import { ExitExecutor } from './ExitExecutor'
+
+export class RiskEngine {
+  private executor = new ExitExecutor()
+
+  constructor(
+    private store: OrderStore,
+    private exchanges: Record<string, ExchangeAdapter>,
+  ) {}
+
+  place(o: LogicalOrder) {
+    this.store.set(o)
+  }
+
+  cancel(id: string) {
+    this.store.delete(id)
+  }
+
+  list(): LogicalOrder[] {
+    return this.store.values()
+  }
+
+  async tick(): Promise<void> {
+    const grouped: Record<string, Record<string, LogicalOrder[]>> = {}
+
+    for (const o of this.store.values()) {
+      if (!grouped[o.exchangeId]) grouped[o.exchangeId] = {}
+      if (!grouped[o.exchangeId][o.symbol]) grouped[o.exchangeId][o.symbol] = []
+      grouped[o.exchangeId][o.symbol].push(o)
+    }
+
+    for (const [exId, bySymbol] of Object.entries(grouped)) {
+      const ex = this.exchanges[exId]
+      if (!ex) continue
+
+      for (const [symbol, orders] of Object.entries(bySymbol)) {
+        await this.processForSymbol(ex, symbol, orders)
+      }
+    }
+  }
+
+  private async processForSymbol(ex: ExchangeAdapter, symbol: string, orders: LogicalOrder[]) {
+    const ticker = await ex.fetchTicker(symbol)
+    const price = ticker.last
+    if (!price || price <= 0) return
+
+    for (const o of orders) {
+      if (o.kind === 'take-profit') {
+        const tp = o as TakeProfitOrder
+        // MVP: TP условие только для "sell exit" логики (и spot, и futures)
+        if (price >= tp.triggerPrice) {
+          await this.executeAndClear(ex, o, price)
+        }
+      } else if (o.kind === 'stop-loss') {
+        const sl = o as StopLossOrder
+        if (price <= sl.triggerPrice) {
+          await this.executeAndClear(ex, o, price)
+        }
+      } else if (o.kind === 'trailing-stop') {
+        const ts = o as TrailingStopOrder
+
+        if (typeof ts.activationPrice === 'number' && ts.activationPrice > 0 && price < ts.activationPrice) {
+          continue
+        }
+
+        if (!ts.highWatermark || price > ts.highWatermark) {
+          ts.highWatermark = price
+          this.store.set(ts)
+          continue
+        }
+
+        const drop = (ts.highWatermark - price) / ts.highWatermark
+        if (drop >= ts.callbackRate) {
+          await this.executeAndClear(ex, o, price)
+        }
+      }
+    }
+  }
+
+  private async executeAndClear(ex: ExchangeAdapter, o: LogicalOrder, price: number) {
+    // 1) удалить триггернувшийся
+    this.store.delete(o.id)
+
+    // 2) удалить “похожие” exits по symbol/exchange (особенно важно для spot sell exits)
+    for (const ord of this.store.values()) {
+      if (ord.exchangeId === o.exchangeId && ord.symbol === o.symbol && ord.market === o.market) {
+        // если это один и тот же "exit stack" — удаляем
+        // (можно ужесточить фильтры позже: по positionSide / side)
+        if (ord.kind === 'take-profit' || ord.kind === 'stop-loss' || ord.kind === 'trailing-stop') {
+          this.store.delete(ord.id)
+        }
+      }
+    }
+
+    // 3) исполнить выход
+    await this.executor.execute(ex, o, price)
+  }
+}

package/src/risk/RiskScheduler.ts

@@ -0,0 +1,23 @@
+import { RiskEngine } from './RiskEngine'
+
+export class RiskScheduler {
+  private timer: NodeJS.Timeout | null = null
+
+  constructor(
+    private engine: RiskEngine,
+    private pollIntervalMs: number,
+  ) {}
+
+  start() {
+    if (this.timer) return
+    this.timer = setInterval(() => {
+      this.engine.tick().catch((e) => console.error('[RiskScheduler] tick error', e))
+    }, this.pollIntervalMs)
+  }
+
+  stop() {
+    if (!this.timer) return
+    clearInterval(this.timer)
+    this.timer = null
+  }
+}

package/src/services/ExchangeRegistry.ts

@@ -0,0 +1,27 @@
+import type { ExchangeAdapter } from '../core/exchange'
+
+export class ExchangeRegistry {
+  private adapters: Record<string, ExchangeAdapter> = {}
+
+  register(ex: ExchangeAdapter) {
+    this.adapters[ex.id] = ex
+  }
+
+  get(id: string): ExchangeAdapter | undefined {
+    return this.adapters[id]
+  }
+
+  require(id: string): ExchangeAdapter {
+    const ex = this.adapters[id]
+    if (!ex) throw new Error(`Exchange ${id} is not configured`)
+    return ex
+  }
+
+  list(): ExchangeAdapter[] {
+    return Object.values(this.adapters)
+  }
+
+  asRecord(): Record<string, ExchangeAdapter> {
+    return this.adapters
+  }
+}

package/tsconfig.json

@@ -1,14 +1,13 @@
 {
   "compilerOptions": {
-    "target": "ES2020",
-    "module": "ES2020",
+    "target": "ES2019",
+    "module": "CommonJS",
     "moduleResolution": "Node",
     "declaration": true,
     "outDir": "dist",
     "rootDir": "src",
-    "strict": true,
     "esModuleInterop": true,
-    "resolveJsonModule": true,
+    "strict": true,
     "skipLibCheck": true
   },
   "include": ["src"]

package/examples/main.ts

@@ -1,77 +0,0 @@
-import 'dotenv/config'
-import { FluxAction } from '../src'
-import type { TrailingStopOrder, TakeProfitOrder, StopLossOrder } from '../src/core/logicalOrders'
-
-async function main() {
-  const flux = new FluxAction({
-    gate: {
-      apiKey: process.env.GATE_API_KEY || '',
-      secret: process.env.GATE_SECRET_KEY || '',
-    },
-    risk: { pollIntervalMs: 500 },
-  })
-
-  await flux.init()
-
-  const symbol = 'BTC/USDT'
-  const exchangeId = 'gate-spot'
-  const quoteCost = 10
-
-  console.log('[test] openSpotPosition', { exchangeId, symbol, quoteCost })
-  const { orderId, filledBase, avgPrice } = await flux.openSpotPosition({
-    exchangeId,
-    symbol,
-    quoteCost,
-  })
-  console.log('[test] opened', { orderId, filledBase, avgPrice })
-
-  const sellQty = filledBase * 0.9
-  const tpPrice = avgPrice * 1.04
-  const slPrice = avgPrice * 0.9 
-
-  const baseId = `${exchangeId}:${symbol}:${Date.now()}`
-
-  const tp: TakeProfitOrder = {
-    id: baseId + ':tp',
-    exchangeId,
-    symbol,
-    side: 'sell',
-    qty: sellQty,
-    kind: 'take-profit',
-    triggerPrice: tpPrice,
-  }
-
-  const ts: TrailingStopOrder = {
-    id: baseId + ':ts',
-    exchangeId,
-    symbol,
-    side: 'sell',
-    qty: sellQty,
-    kind: 'trailing-stop',
-    callbackRate: 0.04,
-    activationPrice: avgPrice,
-    highWatermark: avgPrice,
-  }
-
-  const sl: StopLossOrder = {
-    id: baseId + ':sl',
-    exchangeId,
-    symbol,
-    side: 'sell',
-    qty: sellQty,
-    kind: 'stop-loss',
-    triggerPrice: slPrice,
-  }
-
-  await flux.placeTakeProfit(tp)
-  await flux.placeTrailingStop(ts)
-  await flux.placeStopLoss(sl)
-
-  console.log('[test] TP, SL & trailing registered', { sellQty, tpPrice, slPrice })
-  console.log('[test] waiting RiskManager to act... (keep process running)')
-}
-
-main().catch((e) => {
-  console.error('[test] error', e)
-  process.exit(1)
-})

package/src/core/RiskManager.ts

@@ -1,205 +0,0 @@
-import type { ExchangeAdapter } from './exchange'
-import type {
-  LogicalOrder,
-  TakeProfitOrder,
-  StopLossOrder,
-  TrailingStopOrder,
-} from './logicalOrders'
-
-export interface RiskManagerConfig {
-  exchanges: Record<string, ExchangeAdapter>
-  pollIntervalMs?: number
-}
-
-export class RiskManager {
-  private cfg: RiskManagerConfig
-  private orders = new Map<string, LogicalOrder>()
-  private started = false
-
-  constructor(cfg: RiskManagerConfig) {
-    this.cfg = cfg
-  }
-
-  registerExchange(ex: ExchangeAdapter) {
-    this.cfg.exchanges[ex.id] = ex
-  }
-
-  async placeTakeProfit(o: TakeProfitOrder) {
-    this.orders.set(o.id, o)
-    const ex = this.cfg.exchanges[o.exchangeId]
-    if (!ex) throw new Error(`no exchange ${o.exchangeId}`)
-    if (ex.capabilities.spot.nativeTakeProfit) {
-      // TODO
-    } else {
-      this.startPolling()
-    }
-  }
-
-  async placeStopLoss(o: StopLossOrder) {
-    this.orders.set(o.id, o)
-    const ex = this.cfg.exchanges[o.exchangeId]
-    if (!ex) throw new Error(`no exchange ${o.exchangeId}`)
-    if (ex.capabilities.spot.nativeStopLoss) {
-      // TODO
-    } else {
-      this.startPolling()
-    }
-  }
-
-  async placeTrailingStop(o: TrailingStopOrder) {
-    this.orders.set(o.id, o)
-    const ex = this.cfg.exchanges[o.exchangeId]
-    if (!ex) throw new Error(`no exchange ${o.exchangeId}`)
-    if (ex.capabilities.spot.nativeTrailingStop) {
-      // TODO
-    } else {
-      this.startPolling()
-    }
-  }
-
-  async cancel(id: string) {
-    this.orders.delete(id)
-  }
-
-  getActiveOrders(): LogicalOrder[] {
-    return [...this.orders.values()]
-  }
-
-  private startPolling() {
-    if (this.started) return
-    this.started = true
-    const interval = this.cfg.pollIntervalMs ?? 3_000
-    setInterval(() => {
-      this.tick().catch((e) => {
-        console.error('[RiskManager] tick error', e)
-      })
-    }, interval)
-  }
-
-  private async tick() {
-    const grouped: Record<string, Record<string, LogicalOrder[]>> = {}
-    for (const o of this.orders.values()) {
-      if (!grouped[o.exchangeId]) grouped[o.exchangeId] = {}
-      if (!grouped[o.exchangeId][o.symbol]) grouped[o.exchangeId][o.symbol] = []
-      grouped[o.exchangeId][o.symbol].push(o)
-    }
-
-    for (const [exId, bySymbol] of Object.entries(grouped)) {
-      const ex = this.cfg.exchanges[exId]
-      if (!ex) continue
-      for (const [symbol, orders] of Object.entries(bySymbol)) {
-        await this.processForSymbol(ex, symbol, orders)
-      }
-    }
-  }
-
-  private async processForSymbol(
-    ex: ExchangeAdapter,
-    symbol: string,
-    orders: LogicalOrder[],
-  ) {
-    const ticker = await ex.fetchTicker(symbol)
-    const price = ticker.last
-    if (!price || price <= 0) return
-
-    for (const o of orders) {
-      if (o.kind === 'take-profit') {
-        const tp = o as TakeProfitOrder
-        if (o.side === 'sell' && price >= tp.triggerPrice) {
-          console.log('[RiskManager] TP condition hit', {
-            id: o.id,
-            price,
-            triggerPrice: tp.triggerPrice,
-          })
-          await this.executeAndClear(ex, o, price)
-        }
-      } else if (o.kind === 'stop-loss') {
-        const sl = o as StopLossOrder
-        if (o.side === 'sell' && price <= sl.triggerPrice) {
-          console.log('[RiskManager] SL condition hit', {
-            id: o.id,
-            price,
-            triggerPrice: sl.triggerPrice,
-          })
-          await this.executeAndClear(ex, o, price)
-        }
-      } else if (o.kind === 'trailing-stop') {
-        const ts = o as TrailingStopOrder
-        if (!ts.highWatermark || price > ts.highWatermark) {
-          ts.highWatermark = price
-          this.orders.set(o.id, ts)
-          continue
-        }
-        const drop = (ts.highWatermark - price) / ts.highWatermark
-        
-        if (drop >= ts.callbackRate) {
-          console.log('[RiskManager] TRAILING condition hit', {
-            id: o.id,
-            price,
-            highWatermark: ts.highWatermark,
-            drop,
-          })
-          await this.executeAndClear(ex, o, price)
-        }
-      }
-    }
-  }
-
-  private async executeAndClear(
-    ex: ExchangeAdapter,
-    o: LogicalOrder,
-    price: number,
-) {
-    console.log('[RiskManager] EXIT', {
-      exchangeId: ex.id,
-      symbol: o.symbol,
-      kind: o.kind,
-      side: o.side,
-      qty: o.qty,
-      price,
-    })
-
-    this.orders.delete(o.id)
-
-    if (o.side === 'sell') {
-        for (const [id, ord] of this.orders.entries()) {
-        if (ord.exchangeId === o.exchangeId && ord.symbol === o.symbol && ord.side === 'sell') {
-            this.orders.delete(id)
-        }
-        }
-    }
-
-    const bal = await ex.fetchBalance()
-    const base = o.symbol.split('/')[0]
-    const free = bal[base]?.free ?? 0
-    const rawQty = Math.min(o.qty, free * 0.995)
-
-    if (rawQty <= 0) {
-        console.warn('[RiskManager] skip exit: qty <= 0', { symbol: o.symbol, base, free, requested: o.qty })
-        return
-    }
-
-    if (o.side === 'sell') {
-        try {
-        await ex.marketSellSpot(o.symbol, rawQty)
-        } catch (e: any) {
-        const msg = String(e.message || '')
-        if (msg.includes('too small') && msg.includes('Your order size')) {
-            console.warn('[RiskManager] sell failed: below exchange min size', {
-            symbol: o.symbol,
-            base,
-            free,
-            requested: o.qty,
-            rawQty,
-            error: msg,
-            })
-            return
-        }
-        throw e
-        }
-    } else {
-        const quoteCost = price * rawQty
-        await ex.marketBuySpot(o.symbol, quoteCost)
-    }
-    }
-}