binance-api/archived/debug_scripts/test_optimized_pricing.ts

#!/usr/bin/env npx tsx

import { OptimizedLimitOrderPricingStrategy } from './src/modules/trading/OptimizedLimitOrderPricingStrategy.js'
import { PacificaProxyClient } from './src/exchanges/pacifica/PacificaProxyClient.js'
import { logger } from './src/utils/logger.js'

/**
 * 测试优化的限价单定价策略
 */
async function testOptimizedPricing() {
  console.log('🎯 开始测试优化的限价单定价策略')
  console.log('=' * 60)

  try {
    // 1. 创建 Pacifica 客户端
    const client = new PacificaProxyClient({
      privateKey: process.env.PACIFICA_PRIVATE_KEY_1 || '',
      account: process.env.PACIFICA_ACCOUNT_1 || '3v2fE8y6uPVu5pmNCpmygpGNgdP3kGL3SMoVa86uvLLu',
    })

    // 禁用WebSocket，使用HTTP
    client.setWebSocketEnabled(false)

    // 2. 创建优化定价策略实例（多种配置用于对比）
    const strategies = {
      conservative: new OptimizedLimitOrderPricingStrategy({
        targetFillProbability: 0.9,    // 保守策略：90%成交率
        aggressiveness: 0.3,           // 低激进度
        minProfitMargin: 0.002,        // 较高盈利要求
      }),

      balanced: new OptimizedLimitOrderPricingStrategy({
        targetFillProbability: 0.75,   // 平衡策略：75%成交率
        aggressiveness: 0.6,           // 中等激进度
        minProfitMargin: 0.001,        // 中等盈利要求
      }),

      aggressive: new OptimizedLimitOrderPricingStrategy({
        targetFillProbability: 0.6,    // 激进策略：60%成交率
        aggressiveness: 0.8,           // 高激进度
        minProfitMargin: 0.0005,       // 较低盈利要求
      })
    }

    console.log('📊 测试三种不同的定价策略配置:')
    console.log('  • 保守策略: 高成交率(90%) + 低激进度(30%) + 高盈利要求(0.2%)')
    console.log('  • 平衡策略: 中成交率(75%) + 中激进度(60%) + 中盈利要求(0.1%)')
    console.log('  • 激进策略: 低成交率(60%) + 高激进度(80%) + 低盈利要求(0.05%)')
    console.log()

    // 3. 测试不同订单大小
    const testAmounts = [0.0001, 0.0005, 0.001] // BTC
    const symbol = 'BTC'

    for (const amount of testAmounts) {
      console.log(`\n📏 测试订单大小: ${amount} BTC`)
      console.log('-'.repeat(50))

      for (const [strategyName, strategy] of Object.entries(strategies)) {
        try {
          console.log(`\n🎯 ${strategyName.toUpperCase()} 策略:`)

          const pricing = await strategy.calculateOptimizedPricing(client, symbol, amount)

          if (pricing) {
            const spread = ((pricing.sellPrice - pricing.buyPrice) / pricing.midPrice * 100).toFixed(3)
            const potentialProfit = (pricing.sellPrice - pricing.buyPrice) * amount

            console.log(`  💰 买单价格: $${pricing.buyPrice.toFixed(2)}`)
            console.log(`  💰 卖单价格: $${pricing.sellPrice.toFixed(2)}`)
            console.log(`  📊 中位价格: $${pricing.midPrice.toFixed(2)}`)
            console.log(`  📈 价差: ${spread}%`)
            console.log(`  🎯 成交概率: ${(pricing.confidence * 100).toFixed(1)}%`)
            console.log(`  ⏱️ 预期成交时间: ${pricing.expectedFillTime}秒`)
            console.log(`  💵 预期盈利: $${potentialProfit.toFixed(4)}`)
            console.log(`  📝 策略说明: ${pricing.reasoning}`)

            // 与传统定价比较
            const traditionalBuyPrice = pricing.midPrice * 0.999  // 传统: 中位价-0.1%
            const traditionalSellPrice = pricing.midPrice * 1.001 // 传统: 中位价+0.1%
            const traditionalProfit = (traditionalSellPrice - traditionalBuyPrice) * amount

            const improvement = ((potentialProfit - traditionalProfit) / traditionalProfit * 100).toFixed(1)
            console.log(`  🔄 vs传统定价: ${improvement}% 盈利提升`)

          } else {
            console.log(`  ❌ ${strategyName} 策略: 无法获取定价 (市场条件不适合)`)
          }
        } catch (error: any) {
          console.log(`  ❌ ${strategyName} 策略测试失败: ${error.message}`)
        }
      }
    }

    // 4. 测试策略统计和性能
    console.log('\n📈 策略统计和性能分析:')
    console.log('=' * 60)

    for (const [strategyName, strategy] of Object.entries(strategies)) {
      const stats = strategy.getStats()
      console.log(`\n📊 ${strategyName.toUpperCase()} 策略统计:`)
      console.log(`  • 平均价差: ${(stats.averageSpread * 100).toFixed(3)}%`)
      console.log(`  • 波动率: ${(stats.volatility * 100).toFixed(2)}%`)
      console.log(`  • 最近价差范围: ${stats.recentSpreads.map(s => (s * 100).toFixed(3)).join('%, ')}%`)

      const bestPrices = strategy.getCurrentBestPrices()
      if (bestPrices) {
        console.log(`  • 当前最佳买价: $${bestPrices.bestBid.toFixed(2)}`)
        console.log(`  • 当前最佳卖价: $${bestPrices.bestAsk.toFixed(2)}`)
        console.log(`  • 当前价差: ${(bestPrices.spread * 100).toFixed(3)}%`)
      }
    }

    // 5. 实时价格对比演示
    console.log('\n🔄 实时价格策略对比 (每5秒更新):')
    console.log('=' * 60)

    let iterations = 0
    const maxIterations = 3 // 运行3次演示

    const priceMonitor = setInterval(async () => {
      iterations++

      if (iterations > maxIterations) {
        clearInterval(priceMonitor)
        console.log('\n✅ 优化定价策略测试完成!')
        console.log('\n📋 总结:')
        console.log('  • 智能定价策略可根据实时市场条件动态调整价格')
        console.log('  • 平衡成交概率和盈利margin，提高整体交易效率')
        console.log('  • 不同策略配置适合不同的市场环境和风险偏好')
        console.log('  • 相比固定价差策略，智能定价能显著提升成交率')

        process.exit(0)
        return
      }

      console.log(`\n🕐 实时监控 #${iterations}:`)

      try {
        const balancedPricing = await strategies.balanced.calculateOptimizedPricing(client, symbol, 0.0001)

        if (balancedPricing) {
          console.log(`  时间: ${new Date().toLocaleTimeString()}`)
          console.log(`  最优买价: $${balancedPricing.buyPrice.toFixed(2)} | 最优卖价: $${balancedPricing.sellPrice.toFixed(2)}`)
          console.log(`  成交概率: ${(balancedPricing.confidence * 100).toFixed(1)}% | 预期时间: ${balancedPricing.expectedFillTime}s`)
        }
      } catch (error: any) {
        console.log(`  ⚠️ 实时监控 #${iterations} 失败: ${error.message}`)
      }

    }, 5000)

  } catch (error: any) {
    console.error('❌ 测试失败:', error.message)
    console.error(error.stack)
  }
}

// 运行测试
testOptimizedPricing().catch(error => {
  console.error('🚨 测试脚本执行失败:', error)
  process.exit(1)
})