@metaflux/fluxaction 0.1.5 → 0.1.6

package/src/exchanges/gate/futures/GateFuturesAdapter.ts

@@ -0,0 +1,301 @@
+import ccxt, { type gateio as GateCcxt } from 'ccxt'
+import type {
+  ExchangeAdapter,
+  ExchangeCapabilities,
+  MarketInfo,
+  OrderInfo,
+  PositionInfo,
+  PositionSide,
+} from '../../../core/exchange'
+import { mapCcxtOrder } from '../spot/gate.mapOrder'
+
+export interface GateFuturesAdapterConfig {
+  id: string
+  label?: string
+  apiKey: string
+  secret: string
+  settle?: 'usdt' | 'btc'
+  defaultLeverage?: number
+}
+
+export class GateFuturesAdapter implements ExchangeAdapter {
+  readonly id: string
+  readonly label: string
+  readonly capabilities: ExchangeCapabilities
+
+  private ex: GateCcxt
+  private settle: 'usdt' | 'btc'
+  private defaultLeverage?: number
+
+  constructor(cfg: GateFuturesAdapterConfig) {
+    this.id = cfg.id
+    this.label = cfg.label ?? 'gate-futures'
+    this.settle = cfg.settle ?? 'usdt'
+    this.defaultLeverage = cfg.defaultLeverage
+
+    this.ex = new ccxt.gateio({
+      apiKey: cfg.apiKey,
+      secret: cfg.secret,
+      enableRateLimit: true,
+      options: { defaultType: 'swap' },
+    }) 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 {
+    return false
+  }
+
+  hasFuturesMarket(symbol: string): boolean {
+    const m: any = (this.ex as any).markets?.[symbol]
+    return !!m && (m.type === 'swap' || m.swap === true)
+  }
+
+  getMarket(symbol: string): MarketInfo | undefined {
+    const m: any = (this.ex as any).markets?.[symbol]
+    if (!m) return undefined
+    return {
+      symbol: m.symbol,
+      base: m.base,
+      quote: m.quote,
+      type: 'futures',
+      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: any = (this.ex as any).markets?.[symbol]
+    if (!m) return amount
+    return Number((this.ex as any).amountToPrecision(symbol, amount))
+  }
+
+  private roundPrice(symbol: string, price: number): number {
+    const m: any = (this.ex as any).markets?.[symbol]
+    if (!m) return price
+    return Number((this.ex as any).priceToPrecision(symbol, price))
+  }
+
+  async fetchTicker(symbol: string): Promise<{ last: number }> {
+    const t: any = await (this.ex as any).fetchTicker(symbol)
+    return { last: Number(t?.last ?? 0) }
+  }
+
+  async fetchBalance(): Promise<Record<string, { free: number; used: number; total: number }>> {
+    const bal: any = await (this.ex as any).fetchBalance()
+    return bal as any
+  }
+
+  async fetchOpenOrders(symbol?: string): Promise<OrderInfo[]> {
+    const orders: any[] = await (this.ex as any).fetchOpenOrders(symbol)
+    return orders.map((o: any) => mapCcxtOrder(o.symbol, o))
+  }
+
+  async cancelOrder(symbol: string, orderId: string): Promise<void> {
+    await (this.ex as any).cancelOrder(orderId, symbol)
+  }
+
+  // ===== helpers =====
+  private getMarketRaw(symbol: string): any {
+    const m: any = (this.ex as any).markets?.[symbol]
+    if (!m) throw new Error(`gate-futures: unknown market ${symbol}`)
+    return m
+  }
+
+  private getContractSize(symbol: string): number {
+    const m = this.getMarketRaw(symbol)
+    const cs = Number(m.contractSize ?? 1)
+    return cs > 0 ? cs : 1
+  }
+
+  /**
+   * Конвертирует USDT стоимость в дробное количество контрактов
+   * Gate API поддерживает дробные размеры через X-Gate-Size-Decimal: 1
+   */
+  private costUSDTToContracts(symbol: string, costUSDT: number, price: number): number {
+    const contractSize = this.getContractSize(symbol)
+    const notionalPerContract = price * contractSize
+
+    // Дробное количество контрактов (может быть 0.17, 1.71 и т.д.)
+    const contractsFloat = costUSDT / notionalPerContract
+
+    if (contractsFloat < 0.0001) {
+      throw new Error(
+        `gate-futures: costUSDT too small. ` +
+        `Minimum notional per contract: ${notionalPerContract.toFixed(2)} USDT, got ${costUSDT}`,
+      )
+    }
+
+    return contractsFloat
+  }
+
+  async quoteToBaseQty(params: { symbol: string; quoteCost: number; price?: number }): Promise<number> {
+    const { symbol, quoteCost } = params
+    if (!quoteCost || quoteCost <= 0) throw new Error(`gate-futures quoteCost must be > 0, got ${quoteCost}`)
+
+    const p = params.price ?? (await this.fetchTicker(symbol)).last
+    if (!p || p <= 0) throw new Error(`gate-futures invalid price for ${symbol}: ${p}`)
+
+    // Возвращаем дробное количество контрактов
+    const contracts = this.costUSDTToContracts(symbol, quoteCost, p)
+    return contracts
+  }
+
+  async baseQtyToQuote(params: { symbol: string; baseQty: number; price?: number }): Promise<number> {
+    // baseQty здесь = contracts (может быть дробное)
+    if (!params.baseQty || params.baseQty <= 0) return 0
+
+    const p = params.price ?? (await this.fetchTicker(params.symbol)).last
+    if (!p || p <= 0) throw new Error(`gate-futures invalid price for ${params.symbol}: ${p}`)
+
+    const contractSize = this.getContractSize(params.symbol)
+    // contracts * contractSize * price = notional in USDT
+    return params.baseQty * contractSize * p
+  }
+
+  // ===== spot methods not supported =====
+  async marketBuySpot(): Promise<OrderInfo> {
+    throw new Error('gate-futures: spot not supported')
+  }
+  async marketSellSpot(): Promise<OrderInfo> {
+    throw new Error('gate-futures: spot not supported')
+  }
+  async limitOrderSpot(): Promise<OrderInfo> {
+    throw new Error('gate-futures: spot not supported')
+  }
+
+  // ===== futures =====
+  async openFutures(params: {
+    symbol: string
+    side: PositionSide
+    costUSDT: number
+    leverage?: number
+    price?: number | null
+  }): Promise<OrderInfo> {
+    const symbol = params.symbol
+
+    // Set leverage
+    const leverage = params.leverage ?? this.defaultLeverage
+    if (leverage) {
+      try {
+        await (this.ex as any).setLeverage(leverage, symbol)
+      } catch {
+        // ignore best-effort
+      }
+    }
+
+    // Конвертируем costUSDT -> contracts (дробное)
+    const last = (await this.fetchTicker(symbol)).last
+    const contracts = await this.quoteToBaseQty({ symbol, quoteCost: params.costUSDT, price: last })
+    const actualCostUSDT = await this.baseQtyToQuote({ symbol, baseQty: contracts, price: last })
+
+    console.log(
+      `[${this.id}] openFutures: ` +
+      `requested ${params.costUSDT} USDT -> ` +
+      `calculated ${contracts.toFixed(8)} contracts -> ` +
+      `notional ${actualCostUSDT.toFixed(2)} USDT`,
+    )
+
+    const side = params.side === 'long' ? 'buy' : 'sell'
+    const type: 'market' | 'limit' = typeof params.price === 'number' ? 'limit' : 'market'
+    const price = typeof params.price === 'number' ? this.roundPrice(symbol, params.price) : undefined
+
+    // DEBUG: выводим то, что передаём в createOrder
+    console.log(`[${this.id}] createOrder args: symbol=${symbol}, type=${type}, side=${side}, amount=${contracts}, price=${price}`)
+
+    // Создаём ордер с дробным количеством контрактов
+    const order: any = await (this.ex as any).createOrder(symbol, type, side, contracts, price, {
+      settle: this.settle,
+    })
+
+    console.log(`[${this.id}] createOrder response: id=${order.id}, filled=${order.filled}, cost=${order.cost}, status=${order.status}`)
+
+    // fetchOrder чтобы получить точные filled values
+    const filledOrder: any = await (this.ex as any).fetchOrder(order.id, symbol).catch(() => order)
+
+    console.log(
+      `[${this.id}] fetchOrder response: id=${filledOrder.id}, filled=${filledOrder.filled}, cost=${filledOrder.cost}, average=${filledOrder.average}`,
+    )
+
+    return mapCcxtOrder(symbol, filledOrder)
+  }
+
+  async closeFutures(params: {
+    symbol: string
+    side: PositionSide
+    closeMode: 'all' | 'cost'
+    costUSDT?: number
+  }): Promise<OrderInfo> {
+    const symbol = params.symbol
+    const closeSide = params.side === 'long' ? 'sell' : 'buy'
+
+    if (params.closeMode === 'cost') {
+      if (!params.costUSDT) throw new Error('gate-futures closeMode=cost requires costUSDT')
+
+      const last = (await this.fetchTicker(symbol)).last
+      const contracts = await this.quoteToBaseQty({
+        symbol,
+        quoteCost: params.costUSDT,
+        price: last,
+      })
+
+      const order: any = await (this.ex as any).createOrder(symbol, 'market', closeSide, contracts, undefined, {
+        settle: this.settle,
+        reduceOnly: true,
+      })
+
+      const filledOrder: any = await (this.ex as any).fetchOrder(order.id, symbol).catch(() => order)
+      return mapCcxtOrder(symbol, filledOrder)
+    }
+
+    // closeMode === 'all': close entire position
+    const positions: any[] = await (this.ex as any).fetchPositions?.([symbol]).catch(() => []) ?? []
+    const p0: any = positions.find((p) => p?.symbol === symbol) ?? positions[0]
+    const rawSize = Math.abs(Number(p0?.contracts ?? p0?.size ?? p0?.positionAmt ?? 0))
+
+    if (!rawSize || rawSize <= 0) {
+      throw new Error(`gate-futures closeMode=all: no open position for ${symbol}`)
+    }
+
+    const order: any = await (this.ex as any).createOrder(symbol, 'market', closeSide, rawSize, undefined, {
+      settle: this.settle,
+      reduceOnly: true,
+    })
+
+    const filledOrder: any = await (this.ex as any).fetchOrder(order.id, symbol).catch(() => order)
+    return mapCcxtOrder(symbol, filledOrder)
+  }
+
+  async fetchPositions(symbol?: string): Promise<PositionInfo[]> {
+    const positions: any[] = await (this.ex as any).fetchPositions?.(symbol ? [symbol] : undefined).catch(() => []) ?? []
+    if (!Array.isArray(positions)) return []
+
+    return positions.map((p: any) => {
+      const rawSize = Number(p?.contracts ?? p?.size ?? p?.positionAmt ?? 0)
+      const side: PositionSide =
+        p?.side === 'long' || p?.side === 'short'
+          ? p.side
+          : rawSize >= 0
+            ? 'long'
+            : 'short'
+
+      return {
+        symbol: p?.symbol ?? symbol ?? '',
+        side,
+        size: Math.abs(rawSize),
+        entryPrice: Number(p?.entryPrice ?? p?.entry ?? 0),
+        raw: p,
+      }
+    })
+  }
+}

package/src/exchanges/gate/index.ts

@@ -0,0 +1,2 @@
+export { GateSpotAdapter, type GateSpotAdapterConfig } from './spot/GateSpotAdapter'
+export { GateFuturesAdapter, type GateFuturesAdapterConfig } from './futures/GateFuturesAdapter'

package/src/exchanges/gate/spot/GateSpotAdapter.ts

@@ -0,0 +1,208 @@
+import ccxt, { type gateio as GateCcxt } from 'ccxt'
+import type {
+  ExchangeAdapter,
+  ExchangeCapabilities,
+  MarketInfo,
+  OrderInfo,
+  PositionInfo,
+} from '../../../core/exchange'
+import { mapCcxtOrder } from './gate.mapOrder'
+
+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: any = (this.ex as any).markets?.[symbol]
+    return !!m && m.type === 'spot'
+  }
+
+  hasFuturesMarket(_symbol: string): boolean {
+    return false
+  }
+
+  getMarket(symbol: string): MarketInfo | undefined {
+    const m: any = (this.ex as any).markets?.[symbol]
+    if (!m) return undefined
+    return {
+      symbol: m.symbol,
+      base: m.base,
+      quote: m.quote,
+      type: 'spot',
+      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: any = (this.ex as any).markets?.[symbol]
+    if (!m) return amount
+    return Number((this.ex as any).amountToPrecision(symbol, amount))
+  }
+
+  private roundPrice(symbol: string, price: number): number {
+    const m: any = (this.ex as any).markets?.[symbol]
+    if (!m) return price
+    return Number((this.ex as any).priceToPrecision(symbol, price))
+  }
+
+  async fetchTicker(symbol: string): Promise<{ last: number }> {
+    const t: any = await (this.ex as any).fetchTicker(symbol)
+    return { last: Number(t?.last ?? 0) }
+  }
+
+  async fetchBalance(): Promise<Record<string, { free: number; used: number; total: number }>> {
+    const bal: any = await (this.ex as any).fetchBalance()
+    return bal as any
+  }
+
+  async fetchOpenOrders(symbol?: string): Promise<OrderInfo[]> {
+    const orders: any[] = await (this.ex as any).fetchOpenOrders(symbol)
+    return orders.map((o: any) => mapCcxtOrder(o.symbol, o))
+  }
+
+  async cancelOrder(symbol: string, orderId: string): Promise<void> {
+    await (this.ex as any).cancelOrder(orderId, symbol)
+  }
+
+  async quoteToBaseQty(params: { symbol: string; quoteCost: number; price?: number }): Promise<number> {
+    const { symbol, quoteCost } = params
+    if (!quoteCost || quoteCost <= 0) throw new Error(`gate-spot quoteCost must be > 0, got ${quoteCost}`)
+
+    const p = params.price ?? (await this.fetchTicker(symbol)).last
+    if (!p || p <= 0) throw new Error(`gate-spot invalid price for ${symbol}: ${p}`)
+
+    const m = this.getMarket(symbol)
+
+    // 1) первичное значение и округление вниз (как обычно делает ccxt)
+    let baseQty = this.roundAmount(symbol, quoteCost / p)
+
+    // 2) minAmount
+    if (m?.minAmount && baseQty < m.minAmount) {
+      baseQty = this.roundAmount(symbol, m.minAmount)
+    }
+
+    // 3) minCost (ключевой фикс): если из-за округления ниже minCost — увеличиваем на один шаг
+    if (m?.minCost) {
+      const cost = baseQty * p
+      if (cost + 1e-12 < m.minCost) {
+        // вычисляем 1 шаг по precision.amount
+        const prec = m.precisionAmount
+        if (typeof prec === 'number') {
+          const step = Math.pow(10, -prec)
+          baseQty = this.roundAmount(symbol, baseQty + step)
+        } else {
+          // fallback: небольшой буфер по quoteCost
+          baseQty = this.roundAmount(symbol, (quoteCost * 1.002) / p)
+        }
+      }
+      if (baseQty * p + 1e-12 < m.minCost) {
+        throw new Error(`gate-spot violates minCost: ${baseQty * p} < ${m.minCost} ${m.quote}`)
+      }
+    }
+
+    return baseQty
+  }
+
+  async baseQtyToQuote(params: { symbol: string; baseQty: number; price?: number }): Promise<number> {
+    const qty = this.roundAmount(params.symbol, params.baseQty)
+    if (!qty || qty <= 0) return 0
+    const p = params.price ?? (await this.fetchTicker(params.symbol)).last
+    if (!p || p <= 0) throw new Error(`gate-spot invalid price for ${params.symbol}: ${p}`)
+    return qty * p
+  }
+
+  // spot trading
+  async marketBuySpot(symbol: string, quoteCost: number): Promise<OrderInfo> {
+    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: any = await (this.ex as any).createMarketBuyOrderWithCost(symbol, quoteCost, {
+      createMarketBuyOrderRequiresPrice: false,
+    })
+
+    return mapCcxtOrder(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: ${amount}`)
+
+    const m = this.getMarket(symbol)
+    if (m?.minAmount && amount < m.minAmount) {
+      throw new Error(`gate-spot sell violates minAmount: ${amount} < ${m.minAmount} ${m.base}`)
+    }
+
+    const order: any = await (this.ex as any).createOrder(symbol, 'market', 'sell', amount)
+    return mapCcxtOrder(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: ${amount}`)
+    if (!p || p <= 0) throw new Error(`gate-spot limit price invalid: ${p}`)
+
+    const m = this.getMarket(symbol)
+    if (m?.minAmount && amount < m.minAmount) {
+      throw new Error(`gate-spot limit violates minAmount: ${amount} < ${m.minAmount} ${m.base}`)
+    }
+    if (m?.minCost && amount * p < m.minCost) {
+      throw new Error(`gate-spot limit violates minCost: ${amount * p} < ${m.minCost} ${m.quote}`)
+    }
+
+    const order: any = await (this.ex as any).createOrder(symbol, 'limit', side, amount, p)
+    return mapCcxtOrder(symbol, order)
+  }
+
+  // futures not supported
+  async openFutures(): Promise<OrderInfo> {
+    throw new Error('gate-spot: futures not supported')
+  }
+  async closeFutures(): Promise<OrderInfo> {
+    throw new Error('gate-spot: futures not supported')
+  }
+
+  // positions for spot: empty (НЕ используем ccxt Position typing)
+  async fetchPositions(): Promise<PositionInfo[]> {
+    return []
+  }
+}

package/src/exchanges/gate/spot/gate.mapOrder.ts

@@ -0,0 +1,22 @@
+import type { OrderInfo } from '../../../core/exchange'
+
+export function mapCcxtOrder(symbol: string, o: any): OrderInfo {
+  const price = o.price ?? o.average ?? o.avgPrice
+
+  // ВАЖНО: в ccxt amount обычно base, filled тоже base, cost = quote.
+  const amount =
+    typeof o.filled === 'number' && o.filled > 0 ? o.filled :
+    typeof o.amount === 'number' && o.amount > 0 ? o.amount :
+    0
+
+  return {
+    id: String(o.id),
+    symbol,
+    side: o.side,
+    type: o.type,
+    price,
+    amount,
+    status: o.status,
+    raw: o,
+  }
+}

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'