当前系统完全使用市价单模式,存在以下问题:
client.createMarketOrder()信号生成 → 风险检查 → 市价单执行 → 状态更新
通过智能挂单+市价单组合,降低交易成本,提高刷量效率:
interface OrderTypeStrategy {
// 订单类型决策
decidOrderType(context: TradingContext): 'limit' | 'market'
// 价格计算
calculateLimitPrice(currentPrice: number, side: 'bid' | 'ask'): number
// 超时处理
handleOrderTimeout(orderId: string): void
}
graph TD
A[交易信号] --> B[策略选择器]
B --> C{订单类型决策}
C -->|70%概率| D[挂限价单]
C -->|30%概率| E[下市价单]
D --> F[监控挂单状态]
F --> G{是否成交?}
G -->|是| H[完成交易]
G -->|超时| I[撤单]
I --> E
E --> H
// src/modules/trading/OrderTypeStrategy.ts
export class OrderTypeStrategy {
private config = {
limitOrderRatio: 0.7, // 70%挂单概率
priceOffsetRange: [0.001, 0.003], // 0.1%-0.3%价格偏移
orderTimeout: 30000, // 30秒挂单超时
maxActiveOrders: 10, // 最大活跃挂单数
volatilityThreshold: 0.02, // 波动率阈值
}
decidOrderType(context: TradingContext): 'limit' | 'market' {
// 决策逻辑实现
}
calculateLimitPrice(currentPrice: number, side: 'bid' | 'ask', volatility: number): number {
// 价格计算逻辑
}
}
// TradingEngine.ts 修改
private async executeTradeSignal(signal: TradingSignal): Promise<void> {
const orderType = this.orderTypeStrategy.decidOrderType({
signal,
marketCondition: await this.getMarketCondition(),
accountState: this.getAccountState(signal.targetAccount)
})
if (orderType === 'limit') {
await this.executeLimitOrderSignal(signal)
} else {
await this.executeMarketOrderSignal(signal) // 现有逻辑
}
}
private async executeLimitOrderSignal(signal: TradingSignal): Promise<void> {
const currentPrice = await this.getCurrentPrice(signal.symbol)
const limitPrice = this.orderTypeStrategy.calculateLimitPrice(
currentPrice,
signal.action === 'buy' ? 'bid' : 'ask'
)
const result = await client.createLimitOrder({
account: account.account,
symbol: 'BTCUSDT',
amount: signal.amount,
price: limitPrice.toString(),
side: signal.action === 'buy' ? 'bid' : 'ask',
reduceOnly: signal.reduceOnly || false,
})
if (result.success) {
// 启动订单监控
this.startOrderMonitoring(result.data.order_id, signal)
}
}
// src/modules/trading/OrderMonitoringService.ts
export class OrderMonitoringService {
private activeOrders = new Map<string, OrderMonitorInfo>()
startMonitoring(orderId: string, signal: TradingSignal, timeout: number): void {
const monitorInfo = {
orderId,
signal,
startTime: Date.now(),
timeout,
timer: setTimeout(() => this.handleTimeout(orderId), timeout)
}
this.activeOrders.set(orderId, monitorInfo)
this.checkOrderStatus(orderId)
}
private async handleTimeout(orderId: string): Promise<void> {
const orderInfo = this.activeOrders.get(orderId)
if (!orderInfo) return
// 撤销挂单
await this.cancelOrder(orderId)
// 补充市价单
await this.executeMarketOrderFallback(orderInfo.signal)
this.activeOrders.delete(orderId)
}
}
// src/modules/trading/CostBenefitAnalyzer.ts
export class CostBenefitAnalyzer {
calculateTradingCost(orderType: 'limit' | 'market', amount: number, price: number): number {
const feeRate = orderType === 'limit' ? 0.0002 : 0.0005 // Maker vs Taker
return amount * price * feeRate
}
analyzeStrategyPerformance(): StrategyMetrics {
return {
costSavings: this.calculateCostSavings(),
fillRate: this.calculateFillRate(),
efficiency: this.calculateEfficiency(),
}
}
}
# 混合交易策略配置
HYBRID_TRADING_ENABLED=true
LIMIT_ORDER_RATIO=0.7 # 挂单比例 (70%)
PRICE_OFFSET_MIN=0.001 # 最小价格偏移 (0.1%)
PRICE_OFFSET_MAX=0.003 # 最大价格偏移 (0.3%)
ORDER_TIMEOUT=30000 # 挂单超时 (30秒)
MAX_ACTIVE_ORDERS=10 # 最大活跃挂单数
VOLATILITY_THRESHOLD=0.02 # 波动率阈值 (2%)
# 自适应策略配置
ENABLE_ADAPTIVE_RATIO=true # 启用自适应比例调整
HIGH_VOLATILITY_LIMIT_RATIO=0.5 # 高波动时挂单比例 (50%)
LOW_VOLATILITY_LIMIT_RATIO=0.8 # 低波动时挂单比例 (80%)
// src/config/tradingStrategy.ts
export const TRADING_STRATEGY_CONFIG = {
hybrid: {
enabled: process.env.HYBRID_TRADING_ENABLED === 'true',
limitOrderRatio: parseFloat(process.env.LIMIT_ORDER_RATIO || '0.7'),
priceOffset: {
min: parseFloat(process.env.PRICE_OFFSET_MIN || '0.001'),
max: parseFloat(process.env.PRICE_OFFSET_MAX || '0.003'),
},
orderTimeout: parseInt(process.env.ORDER_TIMEOUT || '30000'),
maxActiveOrders: parseInt(process.env.MAX_ACTIVE_ORDERS || '10'),
},
adaptive: {
enabled: process.env.ENABLE_ADAPTIVE_RATIO === 'true',
volatilityThreshold: parseFloat(process.env.VOLATILITY_THRESHOLD || '0.02'),
ratios: {
highVolatility: parseFloat(process.env.HIGH_VOLATILITY_LIMIT_RATIO || '0.5'),
lowVolatility: parseFloat(process.env.LOW_VOLATILITY_LIMIT_RATIO || '0.8'),
}
}
}
# 设置环境变量
export HYBRID_TRADING_ENABLED=true
export LIMIT_ORDER_RATIO=0.7
# 启动系统
npx tsx src/main-modular.ts
# 查看订单统计
yarn trading:stats
# 查看成本分析
yarn trading:cost-analysis
# 查看活跃挂单
yarn trading:active-orders
// 运行时调整策略
const strategy = tradingEngine.getOrderTypeStrategy()
strategy.updateConfig({
limitOrderRatio: 0.8, // 提高挂单比例到80%
priceOffsetRange: [0.0005, 0.002] // 调整价格偏移
})
📞 支持联系: 详细技术实现请参考代码注释和测试用例