@metaflux/fluxaction 0.1.3

package/src/index.ts

@@ -0,0 +1,138 @@
+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 }
+  }
+
+  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,
+} from './core/exchange'
+
+export {
+  GateSpotAdapter,
+  type GateSpotAdapterConfig,
+} from './exchanges/GateSpotAdapter'

package/tsconfig.json

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