@metaflux/fluxaction 0.1.3 → 0.1.6

package/dist/core/RiskManager.js

@@ -1,4 +1,7 @@
-export class RiskManager {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RiskManager = void 0;
+class RiskManager {
     constructor(cfg) {
         this.orders = new Map();
         this.started = false;
@@ -50,10 +53,11 @@ export class RiskManager {
         return [...this.orders.values()];
     }
     startPolling() {
+        var _a;
         if (this.started)
             return;
         this.started = true;
-        const interval = this.cfg.pollIntervalMs ?? 3000;
+        const interval = (_a = this.cfg.pollIntervalMs) !== null && _a !== void 0 ? _a : 3000;
         setInterval(() => {
             this.tick().catch((e) => {
                 console.error('[RiskManager] tick error', e);
@@ -127,6 +131,7 @@ export class RiskManager {
         }
     }
     async executeAndClear(ex, o, price) {
+        var _a, _b;
         console.log('[RiskManager] EXIT', {
             exchangeId: ex.id,
             symbol: o.symbol,
@@ -145,7 +150,7 @@ export class RiskManager {
         }
         const bal = await ex.fetchBalance();
         const base = o.symbol.split('/')[0];
-        const free = bal[base]?.free ?? 0;
+        const free = (_b = (_a = bal[base]) === null || _a === void 0 ? void 0 : _a.free) !== null && _b !== void 0 ? _b : 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 });
@@ -177,3 +182,4 @@ export class RiskManager {
         }
     }
 }
+exports.RiskManager = RiskManager;

package/dist/core/exchange.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/logicalOrders.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/results.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/exchanges/GateSpotAdapter.js

@@ -1,9 +1,16 @@
-import ccxt from 'ccxt';
-export class GateSpotAdapter {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GateSpotAdapter = void 0;
+const ccxt_1 = __importDefault(require("ccxt"));
+class GateSpotAdapter {
     constructor(cfg) {
+        var _a;
         this.id = cfg.id;
-        this.label = cfg.label ?? 'gate-spot';
-        this.ex = new ccxt.gateio({
+        this.label = (_a = cfg.label) !== null && _a !== void 0 ? _a : 'gate-spot';
+        this.ex = new ccxt_1.default.gateio({
             apiKey: cfg.apiKey,
             secret: cfg.secret,
             enableRateLimit: true,
@@ -29,14 +36,16 @@ export class GateSpotAdapter {
         await this.ex.loadMarkets();
     }
     hasSpotMarket(symbol) {
-        const m = this.ex.markets?.[symbol];
+        var _a;
+        const m = (_a = this.ex.markets) === null || _a === void 0 ? void 0 : _a[symbol];
         return !!m && m.type === 'spot';
     }
     hasFuturesMarket() {
         return false;
     }
     getMarket(symbol) {
-        const m = this.ex.markets?.[symbol];
+        var _a, _b, _c, _d, _e, _f, _g;
+        const m = (_a = this.ex.markets) === null || _a === void 0 ? void 0 : _a[symbol];
         if (!m)
             return undefined;
         return {
@@ -44,26 +53,29 @@ export class GateSpotAdapter {
             base: m.base,
             quote: m.quote,
             type: m.type,
-            precisionAmount: m.precision?.amount,
-            precisionPrice: m.precision?.price,
-            minCost: m.limits?.cost?.min,
-            minAmount: m.limits?.amount?.min,
+            precisionAmount: (_b = m.precision) === null || _b === void 0 ? void 0 : _b.amount,
+            precisionPrice: (_c = m.precision) === null || _c === void 0 ? void 0 : _c.price,
+            minCost: (_e = (_d = m.limits) === null || _d === void 0 ? void 0 : _d.cost) === null || _e === void 0 ? void 0 : _e.min,
+            minAmount: (_g = (_f = m.limits) === null || _f === void 0 ? void 0 : _f.amount) === null || _g === void 0 ? void 0 : _g.min,
         };
     }
     roundAmount(symbol, amount) {
-        const m = this.ex.markets?.[symbol];
+        var _a;
+        const m = (_a = this.ex.markets) === null || _a === void 0 ? void 0 : _a[symbol];
         if (!m)
             return amount;
         return Number(this.ex.amountToPrecision(symbol, amount));
     }
     roundPrice(symbol, price) {
-        const m = this.ex.markets?.[symbol];
+        var _a;
+        const m = (_a = this.ex.markets) === null || _a === void 0 ? void 0 : _a[symbol];
         if (!m)
             return price;
         return Number(this.ex.priceToPrecision(symbol, price));
     }
     mapOrder(symbol, o) {
-        const price = o.price ?? o.average ?? o.avgPrice;
+        var _a, _b;
+        const price = (_b = (_a = o.price) !== null && _a !== void 0 ? _a : o.average) !== null && _b !== void 0 ? _b : o.avgPrice;
         let baseAmount;
         if (price && o.cost) {
             baseAmount = o.cost / price;
@@ -89,8 +101,9 @@ export class GateSpotAdapter {
         };
     }
     async fetchTicker(symbol) {
+        var _a;
         const t = await this.ex.fetchTicker(symbol);
-        return { last: t.last ?? 0 };
+        return { last: (_a = t.last) !== null && _a !== void 0 ? _a : 0 };
     }
     async fetchBalance() {
         const bal = await this.ex.fetchBalance();
@@ -109,7 +122,7 @@ export class GateSpotAdapter {
             throw new Error(`gate-spot invalid price for ${symbol}: ${ticker.last}`);
         }
         const m = this.getMarket(symbol);
-        if (m?.minCost && quoteCost < m.minCost) {
+        if ((m === null || m === void 0 ? void 0 : 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, {
@@ -144,3 +157,4 @@ export class GateSpotAdapter {
         return [];
     }
 }
+exports.GateSpotAdapter = GateSpotAdapter;

package/dist/index.js

@@ -1,19 +1,23 @@
-import { RiskManager } from './core/RiskManager';
-import { GateSpotAdapter } from './exchanges/GateSpotAdapter';
-export class FluxAction {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GateSpotAdapter = exports.RiskManager = exports.FluxAction = void 0;
+const RiskManager_1 = require("./core/RiskManager");
+const GateSpotAdapter_1 = require("./exchanges/GateSpotAdapter");
+class FluxAction {
     constructor(cfg) {
+        var _a;
         this.adapters = {};
         if (cfg.gate) {
-            const gate = new GateSpotAdapter({
+            const gate = new GateSpotAdapter_1.GateSpotAdapter({
                 id: 'gate-spot',
                 apiKey: cfg.gate.apiKey,
                 secret: cfg.gate.secret,
             });
             this.adapters[gate.id] = gate;
         }
-        this.risk = new RiskManager({
+        this.risk = new RiskManager_1.RiskManager({
             exchanges: this.adapters,
-            pollIntervalMs: cfg.risk?.pollIntervalMs,
+            pollIntervalMs: (_a = cfg.risk) === null || _a === void 0 ? void 0 : _a.pollIntervalMs,
         });
     }
     async init() {
@@ -23,12 +27,13 @@ export class FluxAction {
         return this.adapters[id];
     }
     async openSpotPosition(params) {
+        var _a;
         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,
+            avgPrice: (_a = order.price) !== null && _a !== void 0 ? _a : 0,
         };
     }
     async closeSpotMarket(params) {
@@ -66,5 +71,8 @@ export class FluxAction {
         return ex;
     }
 }
-export { RiskManager } from './core/RiskManager';
-export { GateSpotAdapter, } from './exchanges/GateSpotAdapter';
+exports.FluxAction = FluxAction;
+var RiskManager_2 = require("./core/RiskManager");
+Object.defineProperty(exports, "RiskManager", { enumerable: true, get: function () { return RiskManager_2.RiskManager; } });
+var GateSpotAdapter_2 = require("./exchanges/GateSpotAdapter");
+Object.defineProperty(exports, "GateSpotAdapter", { enumerable: true, get: function () { return GateSpotAdapter_2.GateSpotAdapter; } });

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@metaflux/fluxaction",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "description": "Programmatic spot trading actions (TP/SL/trailing) for crypto exchanges",
   "main": "dist/index.js",
-  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "start": "ts-node examples/main.ts"
+    "test:spot": "ts-node scripts/spot.ts",
+    "test:futures": "ts-node scripts/futures.ts"
   },
   "keywords": [
     "trading-bot",
@@ -24,7 +24,8 @@
   "author": "wancareri",
   "license": "MIT",
   "dependencies": {
-    "ccxt": "^4.4.0"
+    "ccxt": "^4.4.0",
+    "dotenv": "^17.2.3"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/scripts/futures.ts

@@ -0,0 +1,80 @@
+try { require('dotenv').config() } catch {}
+
+import { FluxAction } from '../src'
+import type { TakeProfitOrder, StopLossOrder, TrailingStopOrder } from '../src/core/logicalOrders'
+
+async function main() {
+  const apiKey = process.env.GATE_API_KEY || ''
+  const secret = process.env.GATE_SECRET_KEY || ''
+  if (!apiKey || !secret) throw new Error('Missing GATE_API_KEY / GATE_SECRET_KEY')
+
+  const flux = new FluxAction({
+    gate: { apiKey, secret },
+    risk: { pollIntervalMs: 300 },
+  })
+
+  await flux.init()
+
+  const exchangeId = 'gate-futures'
+  const symbol = 'BTC/USDT:USDT'
+  const costUSDT = 15
+
+  const open = await flux.openFuturesPosition({
+    exchangeId,
+    symbol,
+    side: 'short',
+    costUSDT,
+    leverage: 3,
+    price: null, // market
+  })
+  console.log('[futures] opened', open)
+
+  const baseId = `${exchangeId}:${symbol}:${Date.now()}`
+
+  const tp: TakeProfitOrder = {
+    id: baseId + ':tp',
+    exchangeId,
+    market: 'futures',
+    symbol,
+    kind: 'take-profit',
+    triggerPrice: 10_000_000,
+    positionSide: 'long',
+    exitMode: 'all',
+  }
+
+  const sl: StopLossOrder = {
+    id: baseId + ':sl',
+    exchangeId,
+    market: 'futures',
+    symbol,
+    kind: 'stop-loss',
+    triggerPrice: 1,
+    positionSide: 'long',
+    exitMode: 'all',
+  }
+
+  const ts: TrailingStopOrder = {
+    id: baseId + ':ts',
+    exchangeId,
+    market: 'futures',
+    symbol,
+    kind: 'trailing-stop',
+    callbackRate: 0.03,
+    activationPrice: undefined,
+    highWatermark: undefined,
+    positionSide: 'long',
+    exitMode: 'all',
+  }
+
+  await flux.placeTakeProfit(tp)
+  await flux.placeStopLoss(sl)
+  await flux.placeTrailingStop(ts)
+
+  console.log('[futures] exits registered', flux.getActiveLogicalOrders().map((o) => o.id))
+  while (true) await new Promise((r) => setTimeout(r, 60_000))
+}
+
+main().catch((e) => {
+  console.error(e)
+  process.exit(1)
+})

package/scripts/spot.ts

@@ -0,0 +1,84 @@
+try { require('dotenv').config() } catch {}
+
+import { FluxAction } from '../src'
+import type { TakeProfitOrder, StopLossOrder, TrailingStopOrder } from '../src/core/logicalOrders'
+
+async function main() {
+  const apiKey = process.env.GATE_API_KEY || ''
+  const secret = process.env.GATE_SECRET_KEY || ''
+  if (!apiKey || !secret) throw new Error('Missing GATE_API_KEY / GATE_SECRET_KEY')
+
+  const flux = new FluxAction({
+    gate: { apiKey, secret },
+    risk: { pollIntervalMs: 300 },
+  })
+
+  await flux.init()
+
+  const exchangeId = 'gate-spot'
+  const symbol = 'DOGE/USDT'
+  const quoteCost = 15
+
+  const open = await flux.openSpotPosition({ exchangeId, symbol, quoteCost })
+  console.log('[spot] opened', open)
+
+  const { baseQty } = await flux.quoteToBaseQty({ exchangeId, symbol, quoteCost: 3, price: open.avgPrice || undefined })
+  const limitOrder = await flux.placeSpotLimit({
+    exchangeId,
+    symbol,
+    side: 'sell',
+    baseQty,
+    price: (open.avgPrice || 0) * 1.1,
+  })
+  console.log('[spot] limit sell placed', limitOrder)
+
+  const qty = open.filledBase * 0.7
+  const baseId = `${exchangeId}:${symbol}:${Date.now()}`
+
+  const tp: TakeProfitOrder = {
+    id: baseId + ':tp',
+    exchangeId,
+    market: 'spot',
+    symbol,
+    side: 'sell',
+    qty,
+    kind: 'take-profit',
+    triggerPrice: open.avgPrice * 1.02,
+  }
+
+  const sl: StopLossOrder = {
+    id: baseId + ':sl',
+    exchangeId,
+    market: 'spot',
+    symbol,
+    side: 'sell',
+    qty,
+    kind: 'stop-loss',
+    triggerPrice: open.avgPrice * 0.95,
+  }
+
+  const ts: TrailingStopOrder = {
+    id: baseId + ':ts',
+    exchangeId,
+    market: 'spot',
+    symbol,
+    side: 'sell',
+    qty,
+    kind: 'trailing-stop',
+    callbackRate: 0.02,
+    activationPrice: open.avgPrice,
+    highWatermark: open.avgPrice,
+  }
+
+  await flux.placeTakeProfit(tp)
+  await flux.placeStopLoss(sl)
+  await flux.placeTrailingStop(ts)
+
+  console.log('[spot] exits registered', flux.getActiveLogicalOrders().map((o) => o.id))
+  while (true) await new Promise((r) => setTimeout(r, 60_000))
+}
+
+main().catch((e) => {
+  console.error(e)
+  process.exit(1)
+})

package/src/FluxAction.ts

@@ -0,0 +1,150 @@
+import type { ExchangeAdapter, PositionSide } from './core/exchange'
+import { ExchangeRegistry } from './services/ExchangeRegistry'
+import { InMemoryOrderStore } from './risk/OrderStore'
+import { RiskEngine } from './risk/RiskEngine'
+import { RiskScheduler } from './risk/RiskScheduler'
+import type {
+  TakeProfitOrder,
+  StopLossOrder,
+  TrailingStopOrder,
+  LogicalOrder,
+} from './core/logicalOrders'
+import { GateSpotAdapter, GateFuturesAdapter } from './exchanges/gate'
+import { GateClient } from './clients/GateClient'
+
+export interface FluxActionConfig {
+  gate?: { apiKey: string; secret: string }
+  gateFutures?: { enabled?: boolean; settle?: 'usdt' | 'btc'; defaultLeverage?: number }
+  risk?: { pollIntervalMs?: number; autoStart?: boolean }
+}
+
+export class FluxAction {
+  private registry = new ExchangeRegistry()
+  private riskEngine: RiskEngine
+  private riskScheduler: RiskScheduler
+
+  readonly gate: GateClient
+
+  constructor(cfg: FluxActionConfig) {
+    if (cfg.gate) {
+      this.registry.register(new GateSpotAdapter({
+        id: 'gate-spot',
+        apiKey: cfg.gate.apiKey,
+        secret: cfg.gate.secret,
+      }))
+
+      const wantFutures = cfg.gateFutures?.enabled ?? true
+      if (wantFutures) {
+        this.registry.register(new GateFuturesAdapter({
+          id: 'gate-futures',
+          apiKey: cfg.gate.apiKey,
+          secret: cfg.gate.secret,
+          settle: cfg.gateFutures?.settle ?? 'usdt',
+          defaultLeverage: cfg.gateFutures?.defaultLeverage,
+        }))
+      }
+    }
+
+    const store = new InMemoryOrderStore()
+    this.riskEngine = new RiskEngine(store, this.registry.asRecord())
+    this.riskScheduler = new RiskScheduler(this.riskEngine, cfg.risk?.pollIntervalMs ?? 3000)
+    if (cfg.risk?.autoStart) this.riskScheduler.start()
+
+    this.gate = new GateClient(this, { spot: 'gate-spot', futures: 'gate-futures' })
+  }
+
+  async init(): Promise<void> {
+    await Promise.all(this.registry.list().map((a) => a.loadMarkets()))
+  }
+
+  getExchange(id: string): ExchangeAdapter | undefined {
+    return this.registry.get(id)
+  }
+
+  // --------- converters ----------
+  async quoteToBaseQty(params: { exchangeId: string; symbol: string; quoteCost: number; price?: number }) {
+    const ex = this.registry.require(params.exchangeId)
+    const baseQty = await ex.quoteToBaseQty({ symbol: params.symbol, quoteCost: params.quoteCost, price: params.price })
+    return { baseQty }
+  }
+
+  async baseQtyToQuote(params: { exchangeId: string; symbol: string; baseQty: number; price?: number }) {
+    const ex = this.registry.require(params.exchangeId)
+    const quoteCost = await ex.baseQtyToQuote({ symbol: params.symbol, baseQty: params.baseQty, price: params.price })
+    return { quoteCost }
+  }
+
+  // --------- universal spot ----------
+  async openSpotPosition(params: { exchangeId: string; symbol: string; quoteCost: number }) {
+    const ex = this.registry.require(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 }) {
+    const ex = this.registry.require(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 }) {
+    const ex = this.registry.require(params.exchangeId)
+    const order = await ex.limitOrderSpot(params.symbol, params.side, params.baseQty, params.price)
+    return { orderId: order.id }
+  }
+
+  // --------- universal futures ----------
+  async openFuturesPosition(params: {
+    exchangeId: string
+    symbol: string
+    side: PositionSide
+    costUSDT: number
+    leverage?: number
+    price?: number | null // null/undefined => market
+  }) {
+    const ex = this.registry.require(params.exchangeId)
+    const order = await ex.openFutures({
+      symbol: params.symbol,
+      side: params.side,
+      costUSDT: params.costUSDT,
+      leverage: params.leverage,
+      price: params.price,
+    })
+    return { orderId: order.id }
+  }
+
+  async closeFuturesPosition(params: {
+    exchangeId: string
+    symbol: string
+    side: PositionSide
+    closeMode: 'all'|'cost'
+    costUSDT?: number
+  }) {
+    const ex = this.registry.require(params.exchangeId)
+    const order = await ex.closeFutures({
+      symbol: params.symbol,
+      side: params.side,
+      closeMode: params.closeMode,
+      costUSDT: params.costUSDT,
+    })
+    return { orderId: order.id }
+  }
+
+  // --------- risk ----------
+  async placeTakeProfit(o: TakeProfitOrder) { this.placeLogical(o); return { id: o.id } }
+  async placeStopLoss(o: StopLossOrder) { this.placeLogical(o); return { id: o.id } }
+  async placeTrailingStop(o: TrailingStopOrder) { this.placeLogical(o); return { id: o.id } }
+
+  async cancelLogical(id: string) { this.riskEngine.cancel(id) }
+  getActiveLogicalOrders(): LogicalOrder[] { return this.riskEngine.list() }
+
+  startRiskPolling() { this.riskScheduler.start() }
+  stopRiskPolling() { this.riskScheduler.stop() }
+
+  private placeLogical(o: LogicalOrder) {
+    const ex = this.registry.get(o.exchangeId)
+    if (!ex) throw new Error(`no exchange ${o.exchangeId}`)
+    this.riskEngine.place(o)
+    this.riskScheduler.start()
+  }
+}

package/src/clients/GateClient.ts

@@ -0,0 +1,52 @@
+import type { PositionSide } from '../core/exchange'
+import type { FluxAction } from '../FluxAction'
+
+export class GateClient {
+  constructor(
+    private flux: FluxAction,
+    private ids: { spot: string; futures: string },
+  ) {}
+
+  // converters
+  quoteToBaseQty(params: { symbol: string; quoteCost: number; price?: number }) {
+    return this.flux.quoteToBaseQty({ exchangeId: this.ids.spot, ...params })
+  }
+
+  baseQtyToQuote(params: { symbol: string; baseQty: number; price?: number }) {
+    return this.flux.baseQtyToQuote({ exchangeId: this.ids.spot, ...params })
+  }
+
+  // spot
+  openSpotPosition(params: { symbol: string; quoteCost: number }) {
+    return this.flux.openSpotPosition({ exchangeId: this.ids.spot, ...params })
+  }
+
+  closeSpotMarket(params: { symbol: string; baseQty: number }) {
+    return this.flux.closeSpotMarket({ exchangeId: this.ids.spot, ...params })
+  }
+
+  placeSpotLimit(params: { symbol: string; side: 'buy' | 'sell'; baseQty: number; price: number }) {
+    return this.flux.placeSpotLimit({ exchangeId: this.ids.spot, ...params })
+  }
+
+  // futures
+  openFuturesPosition(params: {
+    symbol: string
+    side: PositionSide
+    costUSDT: number
+    leverage?: number
+    price?: number | null // null/undefined => market
+  }) {
+    return this.flux.openFuturesPosition({ exchangeId: this.ids.futures, ...params })
+  }
+
+  closeFuturesPosition(params: { symbol: string; side: PositionSide; closeMode?: 'all' | 'cost'; costUSDT?: number }) {
+    return this.flux.closeFuturesPosition({
+      exchangeId: this.ids.futures,
+      symbol: params.symbol,
+      side: params.side,
+      closeMode: params.closeMode ?? 'all',
+      costUSDT: params.costUSDT,
+    })
+  }
+}

package/src/core/exchange.ts

@@ -61,6 +61,11 @@ export interface ExchangeAdapter {
   fetchOpenOrders(symbol?: string): Promise<OrderInfo[]>
   cancelOrder(symbol: string, orderId: string): Promise<void>
 
+  // helpers
+  quoteToBaseQty(params: { symbol: string; quoteCost: number; price?: number }): Promise<number>
+  baseQtyToQuote(params: { symbol: string; baseQty: number; price?: number }): Promise<number>
+
+  // spot
   marketBuySpot(symbol: string, quoteCost: number): Promise<OrderInfo>
   marketSellSpot(symbol: string, baseAmount: number): Promise<OrderInfo>
   limitOrderSpot(
@@ -70,16 +75,19 @@ export interface ExchangeAdapter {
     price: number,
   ): Promise<OrderInfo>
 
+  // futures
   openFutures(params: {
     symbol: string
     side: PositionSide
     costUSDT: number
     leverage?: number
+    price?: number | null 
   }): Promise<OrderInfo>
 
   closeFutures(params: {
     symbol: string
     side: PositionSide
+    closeMode: 'all' | 'cost'
     costUSDT?: number
   }): Promise<OrderInfo>