@metaflux/fluxaction 0.1.5 → 0.1.6

package/src/exchanges/GateSpotAdapter.ts

@@ -1,193 +0,0 @@
-import ccxt, { type gateio as GateCcxt } from 'ccxt'
-import {
-  type ExchangeAdapter,
-  type ExchangeCapabilities,
-  type MarketInfo,
-  type OrderInfo,
-  type PositionInfo,
-} from '../core/exchange'
-
-export interface GateSpotAdapterConfig {
-  id: string
-  label?: string
-  apiKey: string
-  secret: string
-}
-
-export class GateSpotAdapter implements ExchangeAdapter {
-  readonly id: string
-  readonly label: string
-  readonly capabilities: ExchangeCapabilities
-  private ex: GateCcxt
-
-  constructor(cfg: GateSpotAdapterConfig) {
-    this.id = cfg.id
-    this.label = cfg.label ?? 'gate-spot'
-
-    this.ex = new ccxt.gateio({
-      apiKey: cfg.apiKey,
-      secret: cfg.secret,
-      enableRateLimit: true,
-      options: {
-        defaultType: 'spot',
-        createMarketBuyOrderRequiresPrice: false,
-      },
-    }) as GateCcxt
-
-    this.capabilities = {
-      spot: {
-        nativeTakeProfit: false,
-        nativeStopLoss: false,
-        nativeTrailingStop: false,
-      },
-      futures: {
-        nativeTakeProfit: false,
-        nativeStopLoss: false,
-        nativeTrailingStop: false,
-      },
-    }
-  }
-
-  async loadMarkets(): Promise<void> {
-    await this.ex.loadMarkets()
-  }
-
-  hasSpotMarket(symbol: string): boolean {
-    const m = this.ex.markets?.[symbol]
-    return !!m && m.type === 'spot'
-  }
-
-  hasFuturesMarket(): boolean {
-    return false
-  }
-
-  getMarket(symbol: string): MarketInfo | undefined {
-    const m = this.ex.markets?.[symbol]
-    if (!m) return undefined
-    return {
-      symbol: m.symbol,
-      base: m.base,
-      quote: m.quote,
-      type: m.type as any,
-      precisionAmount: m.precision?.amount,
-      precisionPrice: m.precision?.price,
-      minCost: m.limits?.cost?.min,
-      minAmount: m.limits?.amount?.min,
-    }
-  }
-
-  private roundAmount(symbol: string, amount: number): number {
-    const m = this.ex.markets?.[symbol]
-    if (!m) return amount
-    return Number(this.ex.amountToPrecision(symbol, amount))
-  }
-
-  private roundPrice(symbol: string, price: number): number {
-    const m = this.ex.markets?.[symbol]
-    if (!m) return price
-    return Number(this.ex.priceToPrecision(symbol, price))
-  }
-
-  private mapOrder(symbol: string, o: any): OrderInfo {
-    const price = o.price ?? o.average ?? o.avgPrice
-
-    let baseAmount: number
-    if (price && o.cost) {
-      baseAmount = o.cost / price
-    } else if (price && o.amount) {
-      baseAmount = o.amount / price
-    } else if (typeof o.amount === 'number' && o.amount > 0) {
-      baseAmount = o.amount
-    } else {
-      baseAmount = 0
-    }
-
-    return {
-      id: o.id,
-      symbol,
-      side: o.side,
-      type: o.type,
-      price,
-      amount: baseAmount,
-      status: o.status,
-      raw: o,
-    }
-  }
-
-  async fetchTicker(symbol: string): Promise<{ last: number }> {
-    const t = await this.ex.fetchTicker(symbol)
-    return { last: t.last ?? 0 }
-  }
-
-  async fetchBalance() {
-    const bal = await this.ex.fetchBalance()
-    return bal as any
-  }
-
-  async fetchOpenOrders(symbol?: string): Promise<OrderInfo[]> {
-    const orders = await this.ex.fetchOpenOrders(symbol)
-    return orders.map((o: any) => this.mapOrder(o.symbol, o))
-  }
-
-  async cancelOrder(symbol: string, orderId: string): Promise<void> {
-    await this.ex.cancelOrder(orderId, symbol)
-  }
-
-  async marketBuySpot(symbol: string, quoteCost: number): Promise<OrderInfo> {
-    const ticker = await this.fetchTicker(symbol)
-    if (!ticker.last || ticker.last <= 0) {
-      throw new Error(`gate-spot invalid price for ${symbol}: ${ticker.last}`)
-    }
-
-    const m = this.getMarket(symbol)
-    if (m?.minCost && quoteCost < m.minCost) {
-      throw new Error(
-        `gate-spot buy violates minCost: ${quoteCost} < ${m.minCost} ${m.quote}`,
-      )
-    }
-
-    const order = await this.ex.createMarketBuyOrderWithCost(symbol, quoteCost, {
-      createMarketBuyOrderRequiresPrice: false,
-    })
-    return this.mapOrder(symbol, order)
-  }
-
-  async marketSellSpot(symbol: string, baseAmount: number): Promise<OrderInfo> {
-    const amount = this.roundAmount(symbol, baseAmount)
-    if (!amount || amount <= 0) {
-      throw new Error(`gate-spot sell amount too small for ${symbol}: ${amount}`)
-    }
-
-    const order = await this.ex.createOrder(symbol, 'market', 'sell', amount)
-    return this.mapOrder(symbol, order)
-  }
-
-  async limitOrderSpot(
-    symbol: string,
-    side: 'buy' | 'sell',
-    baseAmount: number,
-    price: number,
-  ): Promise<OrderInfo> {
-    const amount = this.roundAmount(symbol, baseAmount)
-    const p = this.roundPrice(symbol, price)
-
-    if (!amount || amount <= 0) {
-      throw new Error(`gate-spot limit amount too small for ${symbol}: ${amount}`)
-    }
-
-    const order = await this.ex.createOrder(symbol, 'limit', side, amount, p)
-    return this.mapOrder(symbol, order)
-  }
-
-  async openFutures(): Promise<OrderInfo> {
-    throw new Error('gate-spot: futures not supported')
-  }
-
-  async closeFutures(): Promise<OrderInfo> {
-    throw new Error('gate-spot: futures not supported')
-  }
-
-  async fetchPositions(): Promise<PositionInfo[]> {
-    return []
-  }
-}