binance-api/examples/t029_simple_bridge_test.ts

/**
 * T029 简化测试：账户管理器桥接服务
 * 测试桥接器的核心功能，不依赖完整的系统编译
 */
import { logger } from '../src/utils/logger.js'

// 模拟现有的 AccountManager
class MockAccountManager {
  private accounts: any[] = []
  private accountStates = new Map<string, any>()

  setAccounts(accounts: any[]) {
    this.accounts = accounts
    this.initializeAccountStates()
  }

  getAccounts(): any[] {
    return this.accounts
  }

  getAccountState(accountId: string): any {
    return this.accountStates.get(accountId)
  }

  getAllAccountStates(): Map<string, any> {
    return this.accountStates
  }

  private initializeAccountStates(): void {
    this.accounts.forEach((account, index) => {
      const accountId = `pacifica-${index + 1}`
      this.accountStates.set(accountId, {
        totalTrades: 0,
        netPosition: 0,
        totalVolume: 0,
        lastBalance: 1000 + Math.random() * 5000,
        availableBalance: 800 + Math.random() * 3000,
        marginUsed: 200 + Math.random() * 1000,
        needsRebalance: false,
      })
    })
  }
}

// 模拟新的数据模型管理器
class MockExchangeAccountManager {
  private accounts = new Map<string, any>()

  addAccount(account: any): void {
    this.accounts.set(account.accountId, account)
  }

  getAllAccounts(): any[] {
    return Array.from(this.accounts.values())
  }
}

class MockRiskEnvelopeManager {
  private envelopes = new Map<string, any>()

  addEnvelope(envelope: any): void {
    this.envelopes.set(envelope.envelopeId, envelope)
  }

  getAllEnvelopes(): any[] {
    return Array.from(this.envelopes.values())
  }
}

class MockMonitoringEventManager {
  private events: any[] = []

  addEvent(event: any): void {
    this.events.push(event)
  }

  getAllEvents(): any[] {
    return this.events
  }
}

// 模拟 AccountSyncService
class MockAccountSyncService {
  async syncAccounts(request: any): Promise<any> {
    logger.info(`模拟账户同步: ${request.accounts.length} 个账户`)
    
    // 模拟同步结果
    const results = request.accounts.map((account: any) => ({
      accountId: account.accountId,
      exchange: account.exchange,
      balances: [
        {
          asset: 'USDC',
          total: '1000.0',
          available: '800.0',
          locked: '200.0'
        }
      ],
      positions: [],
      utilization: {
        current: 0.2,
        targetMin: 0.5,
        targetMax: 0.8,
        needsRebalance: true
      },
      syncedAt: new Date()
    }))

    return {
      requestId: request.requestId,
      results,
      errors: []
    }
  }
}

// 简化的桥接器实现
class SimpleAccountManagerBridge {
  private isRunning = false
  private syncStats = {
    totalSyncs: 0,
    successfulSyncs: 0,
    failedSyncs: 0,
    lastError: null as string | null
  }

  constructor(
    private legacyAccountManager: MockAccountManager,
    private accountSyncService: MockAccountSyncService,
    private exchangeAccountManager: MockExchangeAccountManager,
    private monitoringManager: MockMonitoringEventManager,
    private riskManager: MockRiskEnvelopeManager
  ) {}

  async start(): Promise<void> {
    logger.info('启动简化账户管理器桥接器')
    await this.initializeExchangeAccounts()
    this.isRunning = true
  }

  async stop(): Promise<void> {
    logger.info('停止简化账户管理器桥接器')
    this.isRunning = false
  }

  private async initializeExchangeAccounts(): Promise<void> {
    logger.info('初始化 ExchangeAccount 数据')

    const legacyAccounts = this.legacyAccountManager.getAccounts()
    const accountStates = this.legacyAccountManager.getAllAccountStates()

    for (let i = 0; i < legacyAccounts.length; i++) {
      const legacyAccount = legacyAccounts[i]
      const accountId = `pacifica-${i + 1}`
      const accountState = accountStates.get(accountId)

      if (!accountState) {
        logger.warn(`找不到账户状态: ${accountId}`)
        continue
      }

      // 创建新的 ExchangeAccount
      const exchangeAccount = {
        accountId,
        exchange: 'pacifica',
        accountName: legacyAccount.name || `Pacifica Account ${i + 1}`,
        publicKey: legacyAccount.account,
        proxyProfile: 'default',
        utilizationTargetMin: 0.5,
        utilizationTargetMax: 0.8,
        deltaThreshold: 0.0005,
        maxPositionValue: 10000,
        stopLossConfigId: 'default',
        status: 'active',
        createdAt: new Date(),
        updatedAt: new Date()
      }

      this.exchangeAccountManager.addAccount(exchangeAccount)
      await this.createRiskEnvelope(accountId, exchangeAccount)

      logger.info(`初始化账户: ${accountId} (${exchangeAccount.accountName})`)
    }

    logger.info(`初始化完成，共处理 ${legacyAccounts.length} 个账户`)
  }

  private async createRiskEnvelope(accountId: string, exchangeAccount: any): Promise<void> {
    const riskEnvelope = {
      envelopeId: `envelope-${accountId}`,
      accountId,
      maxDrawdownPercent: 5.0,
      maxLeverage: 1.0,
      deltaThreshold: exchangeAccount.deltaThreshold,
      slippageTolerance: 0.001,
      emergencyStopLossSeconds: 30,
      createdAt: new Date(),
      updatedAt: new Date()
    }

    this.riskManager.addEnvelope(riskEnvelope)
    logger.debug(`创建风险包络: ${accountId}`)
  }

  async triggerManualSync(): Promise<any> {
    logger.info('执行手动账户同步')
    this.syncStats.totalSyncs++

    try {
      const legacyAccounts = this.legacyAccountManager.getAccounts()
      
      const syncRequest = {
        requestId: `sync-${Date.now()}`,
        accounts: legacyAccounts.map((_, index) => ({
          accountId: `pacifica-${index + 1}`,
          exchange: 'pacifica',
          nonce: Date.now()
        }))
      }

      const syncResponse = await this.accountSyncService.syncAccounts(syncRequest)

      if (syncResponse.errors.length === 0) {
        this.syncStats.successfulSyncs++
        this.syncStats.lastError = null
      } else {
        this.syncStats.failedSyncs++
        this.syncStats.lastError = syncResponse.errors[0]?.message || 'Unknown error'
      }

      logger.info(`账户同步完成: ${syncResponse.results.length} 成功, ${syncResponse.errors.length} 失败`)

      return {
        success: true,
        message: '手动同步完成',
        syncStats: { ...this.syncStats }
      }
    } catch (error: any) {
      this.syncStats.failedSyncs++
      this.syncStats.lastError = error.message
      return {
        success: false,
        message: `手动同步失败: ${error.message}`,
        syncStats: { ...this.syncStats }
      }
    }
  }

  getBridgeStats(): any {
    return {
      legacyAccounts: this.legacyAccountManager.getAccounts().length,
      exchangeAccounts: this.exchangeAccountManager.getAllAccounts().length,
      riskEnvelopes: this.riskManager.getAllEnvelopes().length,
      syncStats: { ...this.syncStats },
      isRunning: this.isRunning
    }
  }
}

async function main() {
  logger.info('=== T029 简化桥接器测试 ===')

  try {
    // 1. 创建模拟组件
    const mockAccountManager = new MockAccountManager()
    const mockExchangeAccountManager = new MockExchangeAccountManager()
    const mockRiskManager = new MockRiskEnvelopeManager()
    const mockMonitoringManager = new MockMonitoringEventManager()
    const mockAccountSyncService = new MockAccountSyncService()

    // 2. 模拟账户配置
    const mockAccounts = [
      {
        id: '1',
        name: 'Pacifica Account 1',
        account: '0x1234567890abcdef1234567890abcdef12345678',
        privateKey: 'mock_private_key_1'
      },
      {
        id: '2', 
        name: 'Pacifica Account 2',
        account: '0xabcdef1234567890abcdef1234567890abcdef12',
        privateKey: 'mock_private_key_2'
      }
    ]

    // 3. 设置账户
    mockAccountManager.setAccounts(mockAccounts)

    // 4. 创建桥接器
    const bridge = new SimpleAccountManagerBridge(
      mockAccountManager,
      mockAccountSyncService,
      mockExchangeAccountManager,
      mockMonitoringManager,
      mockRiskManager
    )

    // 5. 启动桥接器
    logger.info('启动桥接器...')
    await bridge.start()

    // 6. 检查初始状态
    const initialStats = bridge.getBridgeStats()
    logger.info('初始桥接统计:', initialStats)

    // 7. 执行手动同步
    logger.info('执行手动同步...')
    const syncResult = await bridge.triggerManualSync()
    logger.info('同步结果:', syncResult)

    // 8. 检查同步后状态
    const finalStats = bridge.getBridgeStats()
    logger.info('最终桥接统计:', finalStats)

    // 9. 验证数据一致性
    logger.info('验证数据一致性...')
    const legacyAccounts = mockAccountManager.getAccounts()
    const exchangeAccounts = mockExchangeAccountManager.getAllAccounts()
    const riskEnvelopes = mockRiskManager.getAllEnvelopes()

    logger.info(`验证结果:`)
    logger.info(`- 现有账户: ${legacyAccounts.length}`)
    logger.info(`- 新架构账户: ${exchangeAccounts.length}`)
    logger.info(`- 风险包络: ${riskEnvelopes.length}`)
    logger.info(`- 数据一致性: ${legacyAccounts.length === exchangeAccounts.length ? '✅' : '❌'}`)

    // 10. 停止桥接器
    await bridge.stop()

    logger.info('=== T029 简化桥接器测试完成 ===')

  } catch (error: any) {
    logger.error('T029 测试失败:', { error: error.message, stack: error.stack })
    process.exit(1)
  }
}

// 运行测试
if (import.meta.url === `file://${process.argv[1]}`) {
  main().catch(error => {
    logger.error('测试运行失败:', error)
    process.exit(1)
  })
}