feat: 重构订单路由逻辑，添加订单意图类型以支持多交易所订单处理

src/exchanges/aster/order.ts

@@ -0,0 +1,101 @@
+import type { AsterOrder, CreateOrderParams } from "../types";
+import type {
+  BaseOrderIntent,
+  ClosePositionIntent,
+  LimitOrderIntent,
+  MarketOrderIntent,
+  StopOrderIntent,
+  TrailingStopOrderIntent,
+} from "../order-schema";
+import { toStringBoolean } from "../order-schema";
+
+function applyCommonFields(params: CreateOrderParams, intent: BaseOrderIntent): CreateOrderParams {
+  if (params.quantity === undefined) {
+    params.quantity = intent.quantity;
+  }
+  if (params.timeInForce === undefined && intent.timeInForce) {
+    params.timeInForce = intent.timeInForce;
+  }
+  if (intent.reduceOnly !== undefined) {
+    params.reduceOnly = toStringBoolean(intent.reduceOnly);
+  }
+  if (intent.closePosition !== undefined) {
+    params.closePosition = toStringBoolean(intent.closePosition);
+  }
+  return params;
+}
+
+export async function createLimitOrder(intent: LimitOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "LIMIT",
+      quantity: intent.quantity,
+      price: intent.price,
+      timeInForce: intent.timeInForce ?? "GTX",
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createMarketOrder(intent: MarketOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "MARKET",
+      quantity: intent.quantity,
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createStopOrder(intent: StopOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "STOP_MARKET",
+      quantity: intent.quantity,
+      stopPrice: intent.stopPrice,
+      timeInForce: intent.timeInForce ?? "GTC",
+      triggerType: intent.triggerType,
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createTrailingStopOrder(intent: TrailingStopOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "TRAILING_STOP_MARKET",
+      quantity: intent.quantity,
+      activationPrice: intent.activationPrice,
+      callbackRate: intent.callbackRate,
+      timeInForce: intent.timeInForce ?? "GTC",
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createClosePositionOrder(intent: ClosePositionIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "MARKET",
+      quantity: intent.quantity,
+      reduceOnly: "true",
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+

src/exchanges/backpack/order.ts

@@ -0,0 +1,88 @@
+import type { AsterOrder, CreateOrderParams } from "../types";
+import type {
+  BaseOrderIntent,
+  ClosePositionIntent,
+  LimitOrderIntent,
+  MarketOrderIntent,
+  StopOrderIntent,
+  TrailingStopOrderIntent,
+} from "../order-schema";
+import { toStringBoolean } from "../order-schema";
+
+function applyCommonFields(params: CreateOrderParams, intent: BaseOrderIntent): CreateOrderParams {
+  if (params.quantity === undefined) {
+    params.quantity = intent.quantity;
+  }
+  if (params.timeInForce === undefined && intent.timeInForce) {
+    params.timeInForce = intent.timeInForce;
+  }
+  if (intent.reduceOnly !== undefined) {
+    params.reduceOnly = toStringBoolean(intent.reduceOnly);
+  }
+  if (intent.closePosition !== undefined) {
+    params.closePosition = toStringBoolean(intent.closePosition);
+  }
+  return params;
+}
+
+export async function createLimitOrder(intent: LimitOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "LIMIT",
+      quantity: intent.quantity,
+      price: intent.price,
+      timeInForce: intent.timeInForce ?? "GTX",
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createMarketOrder(intent: MarketOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "MARKET",
+      quantity: intent.quantity,
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createStopOrder(intent: StopOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "STOP_MARKET",
+      quantity: intent.quantity,
+      stopPrice: intent.stopPrice,
+      timeInForce: intent.timeInForce ?? "GTC",
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createTrailingStopOrder(_intent: TrailingStopOrderIntent): Promise<AsterOrder> {
+  throw new Error("Backpack exchange does not support trailing stop orders");
+}
+
+export async function createClosePositionOrder(intent: ClosePositionIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "MARKET",
+      quantity: intent.quantity,
+      reduceOnly: "true",
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+

src/exchanges/grvt/order.ts

@@ -0,0 +1,92 @@
+import type { AsterOrder, CreateOrderParams } from "../types";
+import type {
+  BaseOrderIntent,
+  ClosePositionIntent,
+  LimitOrderIntent,
+  MarketOrderIntent,
+  StopOrderIntent,
+  TrailingStopOrderIntent,
+} from "../order-schema";
+import { toStringBoolean } from "../order-schema";
+
+function applyCommonFields(params: CreateOrderParams, intent: BaseOrderIntent): CreateOrderParams {
+  if (params.quantity === undefined) {
+    params.quantity = intent.quantity;
+  }
+  if (params.timeInForce === undefined && intent.timeInForce) {
+    params.timeInForce = intent.timeInForce;
+  }
+  if (intent.reduceOnly !== undefined) {
+    params.reduceOnly = toStringBoolean(intent.reduceOnly);
+  }
+  if (intent.closePosition !== undefined) {
+    params.closePosition = toStringBoolean(intent.closePosition);
+  }
+  return params;
+}
+
+export async function createLimitOrder(intent: LimitOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "LIMIT",
+      quantity: intent.quantity,
+      price: intent.price,
+      timeInForce: intent.timeInForce ?? "GTX",
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createMarketOrder(intent: MarketOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "MARKET",
+      quantity: intent.quantity,
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createStopOrder(intent: StopOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "STOP_MARKET",
+      quantity: intent.quantity,
+      stopPrice: intent.stopPrice,
+      timeInForce: intent.timeInForce ?? "GTC",
+      triggerType: intent.triggerType ?? (intent.side === "BUY" ? "TAKE_PROFIT" : "STOP_LOSS"),
+      closePosition: toStringBoolean(intent.closePosition ?? true),
+      reduceOnly: toStringBoolean(intent.reduceOnly ?? true),
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createTrailingStopOrder(_intent: TrailingStopOrderIntent): Promise<AsterOrder> {
+  throw new Error("GRVT exchange does not support trailing stop orders");
+}
+
+export async function createClosePositionOrder(intent: ClosePositionIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "MARKET",
+      quantity: intent.quantity,
+      reduceOnly: "true",
+      closePosition: toStringBoolean(intent.closePosition ?? true),
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+

src/exchanges/lighter/order.ts

@@ -0,0 +1,93 @@
+import type { AsterOrder, CreateOrderParams } from "../types";
+import type {
+  BaseOrderIntent,
+  ClosePositionIntent,
+  LimitOrderIntent,
+  MarketOrderIntent,
+  StopOrderIntent,
+  TrailingStopOrderIntent,
+} from "../order-schema";
+import { toStringBoolean } from "../order-schema";
+
+function applyCommonFields(params: CreateOrderParams, intent: BaseOrderIntent): CreateOrderParams {
+  if (params.quantity === undefined) {
+    params.quantity = intent.quantity;
+  }
+  if (params.timeInForce === undefined && intent.timeInForce) {
+    params.timeInForce = intent.timeInForce;
+  }
+  if (intent.reduceOnly !== undefined) {
+    params.reduceOnly = toStringBoolean(intent.reduceOnly);
+  }
+  if (intent.closePosition !== undefined) {
+    params.closePosition = toStringBoolean(intent.closePosition);
+  }
+  return params;
+}
+
+export async function createLimitOrder(intent: LimitOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "LIMIT",
+      quantity: intent.quantity,
+      price: intent.price,
+      timeInForce: intent.timeInForce ?? "GTC",
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createMarketOrder(intent: MarketOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "MARKET",
+      quantity: intent.quantity,
+      timeInForce: intent.timeInForce ?? "IOC",
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createStopOrder(intent: StopOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "STOP_MARKET",
+      quantity: intent.quantity,
+      stopPrice: intent.stopPrice,
+      timeInForce: intent.timeInForce ?? "GTC",
+      reduceOnly: toStringBoolean(intent.reduceOnly ?? true),
+      closePosition: toStringBoolean(intent.closePosition ?? true),
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createTrailingStopOrder(_intent: TrailingStopOrderIntent): Promise<AsterOrder> {
+  throw new Error("Lighter exchange does not support trailing stop orders");
+}
+
+export async function createClosePositionOrder(intent: ClosePositionIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "MARKET",
+      quantity: intent.quantity,
+      reduceOnly: "true",
+      closePosition: toStringBoolean(intent.closePosition ?? true),
+      timeInForce: intent.timeInForce ?? "IOC",
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+

src/exchanges/order-router.ts

@@ -0,0 +1,118 @@
+import type { ExchangeAdapter } from "./adapter";
+import type { AsterOrder } from "./types";
+import type {
+  BaseOrderIntent,
+  ClosePositionIntent,
+  LimitOrderIntent,
+  MarketOrderIntent,
+  StopOrderIntent,
+  TrailingStopOrderIntent,
+} from "./order-schema";
+import * as asterOrders from "./aster/order";
+import * as backpackOrders from "./backpack/order";
+import * as grvtOrders from "./grvt/order";
+import * as lighterOrders from "./lighter/order";
+import * as paradexOrders from "./paradex/order";
+
+type ExchangeKey = "aster" | "backpack" | "grvt" | "lighter" | "paradex";
+
+interface ExchangeOrderHandlers {
+  limit(intent: LimitOrderIntent): Promise<AsterOrder>;
+  market(intent: MarketOrderIntent): Promise<AsterOrder>;
+  stop(intent: StopOrderIntent): Promise<AsterOrder>;
+  trailingStop?: (intent: TrailingStopOrderIntent) => Promise<AsterOrder>;
+  close(intent: ClosePositionIntent): Promise<AsterOrder>;
+}
+
+const handlerMap: Record<ExchangeKey, ExchangeOrderHandlers> = {
+  aster: {
+    limit: asterOrders.createLimitOrder,
+    market: asterOrders.createMarketOrder,
+    stop: asterOrders.createStopOrder,
+    trailingStop: asterOrders.createTrailingStopOrder,
+    close: asterOrders.createClosePositionOrder,
+  },
+  backpack: {
+    limit: backpackOrders.createLimitOrder,
+    market: backpackOrders.createMarketOrder,
+    stop: backpackOrders.createStopOrder,
+    trailingStop: backpackOrders.createTrailingStopOrder,
+    close: backpackOrders.createClosePositionOrder,
+  },
+  grvt: {
+    limit: grvtOrders.createLimitOrder,
+    market: grvtOrders.createMarketOrder,
+    stop: grvtOrders.createStopOrder,
+    trailingStop: grvtOrders.createTrailingStopOrder,
+    close: grvtOrders.createClosePositionOrder,
+  },
+  lighter: {
+    limit: lighterOrders.createLimitOrder,
+    market: lighterOrders.createMarketOrder,
+    stop: lighterOrders.createStopOrder,
+    trailingStop: lighterOrders.createTrailingStopOrder,
+    close: lighterOrders.createClosePositionOrder,
+  },
+  paradex: {
+    limit: paradexOrders.createLimitOrder,
+    market: paradexOrders.createMarketOrder,
+    stop: paradexOrders.createStopOrder,
+    trailingStop: paradexOrders.createTrailingStopOrder,
+    close: paradexOrders.createClosePositionOrder,
+  },
+};
+
+const knownExchanges: ExchangeKey[] = ["aster", "backpack", "grvt", "lighter", "paradex"];
+
+function normalizeExchangeId(value: string | undefined | null): string | undefined {
+  if (!value) return undefined;
+  return value.trim().toLowerCase();
+}
+
+function resolveExchangeKey(adapter: ExchangeAdapter): ExchangeKey {
+  const fromEnv = normalizeExchangeId(process.env.TRADE_EXCHANGE ?? process.env.EXCHANGE);
+  const candidates = [fromEnv, normalizeExchangeId(adapter.id)];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    if ((knownExchanges as string[]).includes(candidate)) {
+      return candidate as ExchangeKey;
+    }
+  }
+  throw new Error(
+    `Unsupported exchange for order routing: ${candidates.filter(Boolean).join(", ") || "unknown"}`
+  );
+}
+
+function getHandlers(intent: BaseOrderIntent): ExchangeOrderHandlers {
+  const exchangeKey = resolveExchangeKey(intent.adapter);
+  const handlers = handlerMap[exchangeKey];
+  if (!handlers) {
+    throw new Error(`Order handlers not implemented for exchange: ${exchangeKey}`);
+  }
+  return handlers;
+}
+
+export function routeLimitOrder(intent: LimitOrderIntent): Promise<AsterOrder> {
+  return getHandlers(intent).limit(intent);
+}
+
+export function routeMarketOrder(intent: MarketOrderIntent): Promise<AsterOrder> {
+  return getHandlers(intent).market(intent);
+}
+
+export function routeStopOrder(intent: StopOrderIntent): Promise<AsterOrder> {
+  return getHandlers(intent).stop(intent);
+}
+
+export function routeTrailingStopOrder(intent: TrailingStopOrderIntent): Promise<AsterOrder> {
+  const handlers = getHandlers(intent);
+  if (!handlers.trailingStop) {
+    throw new Error("Trailing stop orders are not supported by the current exchange");
+  }
+  return handlers.trailingStop(intent);
+}
+
+export function routeCloseOrder(intent: ClosePositionIntent): Promise<AsterOrder> {
+  return getHandlers(intent).close(intent);
+}
+

src/exchanges/order-schema.ts

@@ -0,0 +1,42 @@
+import type { ExchangeAdapter } from "./adapter";
+import type { OrderSide, TimeInForce } from "./types";
+
+export interface BaseOrderIntent {
+  adapter: ExchangeAdapter;
+  symbol: string;
+  side: OrderSide;
+  quantity: number;
+  reduceOnly?: boolean;
+  closePosition?: boolean;
+  timeInForce?: TimeInForce | "GTX";
+}
+
+export interface LimitOrderIntent extends BaseOrderIntent {
+  price: number;
+}
+
+export interface MarketOrderIntent extends BaseOrderIntent {
+  expectedPrice?: number | null;
+}
+
+export interface StopOrderIntent extends BaseOrderIntent {
+  stopPrice: number;
+  triggerType?: "UNSPECIFIED" | "TAKE_PROFIT" | "STOP_LOSS";
+}
+
+export interface TrailingStopOrderIntent extends BaseOrderIntent {
+  activationPrice: number;
+  callbackRate: number;
+}
+
+export interface ClosePositionIntent extends BaseOrderIntent {
+  expectedPrice?: number | null;
+}
+
+export type ExchangeOrderType = "limit" | "market" | "stop" | "trailingStop" | "close";
+
+export function toStringBoolean(value: boolean | undefined): "true" | "false" | undefined {
+  if (value === undefined) return undefined;
+  return value ? "true" : "false";
+}
+

src/exchanges/paradex/gateway.ts

@@ -602,6 +602,9 @@ export class ParadexGateway {
       // Only omit amount for MARKET close-position orders; STOP requires explicit size
       const shouldOmitAmount = isClosePosition && type === "market";
       const amountArg: any = shouldOmitAmount ? undefined : amount;
+      if (!shouldOmitAmount && amountArg != null && extraParams.size === undefined) {
+        extraParams.size = amountArg.toString();
+      }
       const order = (await this.exchange.createOrder(
         symbol,
         type,

src/exchanges/paradex/order.ts

@@ -0,0 +1,93 @@
+import type { AsterOrder, CreateOrderParams } from "../types";
+import type {
+  BaseOrderIntent,
+  ClosePositionIntent,
+  LimitOrderIntent,
+  MarketOrderIntent,
+  StopOrderIntent,
+  TrailingStopOrderIntent,
+} from "../order-schema";
+import { toStringBoolean } from "../order-schema";
+
+function applyCommonFields(params: CreateOrderParams, intent: BaseOrderIntent): CreateOrderParams {
+  if (params.quantity === undefined) {
+    params.quantity = intent.quantity;
+  }
+  if (params.timeInForce === undefined && intent.timeInForce) {
+    params.timeInForce = intent.timeInForce;
+  }
+  if (intent.reduceOnly !== undefined) {
+    params.reduceOnly = toStringBoolean(intent.reduceOnly);
+  }
+  if (intent.closePosition !== undefined) {
+    params.closePosition = toStringBoolean(intent.closePosition);
+  }
+  return params;
+}
+
+export async function createLimitOrder(intent: LimitOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "LIMIT",
+      quantity: intent.quantity,
+      price: intent.price,
+      timeInForce: intent.timeInForce ?? "GTC",
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createMarketOrder(intent: MarketOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "MARKET",
+      quantity: intent.quantity,
+      timeInForce: intent.timeInForce,
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createStopOrder(intent: StopOrderIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "STOP_MARKET",
+      quantity: intent.quantity,
+      stopPrice: intent.stopPrice,
+      price: intent.stopPrice,
+      timeInForce: intent.timeInForce ?? "GTC",
+      reduceOnly: toStringBoolean(intent.reduceOnly ?? true),
+      closePosition: toStringBoolean(intent.closePosition ?? true),
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}
+
+export async function createTrailingStopOrder(_intent: TrailingStopOrderIntent): Promise<AsterOrder> {
+  throw new Error("Paradex exchange does not support trailing stop orders");
+}
+
+export async function createClosePositionOrder(intent: ClosePositionIntent): Promise<AsterOrder> {
+  const params: CreateOrderParams = applyCommonFields(
+    {
+      symbol: intent.symbol,
+      side: intent.side,
+      type: "MARKET",
+      quantity: intent.quantity,
+      reduceOnly: "true",
+      closePosition: toStringBoolean(intent.closePosition ?? true),
+      timeInForce: intent.timeInForce,
+    },
+    intent
+  );
+  return intent.adapter.createOrder(params);
+}