latency-probe.ts

/**
 * Phase 4: RPC Latency Probe Script
 * Measures RPC latency and ranks them for optimal ordering
 */

import 'dotenv/config'
import { createPublicClient, http, webSocket } from 'viem'
import { beraChain } from '../src/config.js'

interface RpcLatency {
  url: string
  type: 'HTTP' | 'WS'
  blockNumberLatency: number
  callLatency: number
  avgLatency: number
  success: boolean
  error?: string
}

async function probeRpcLatency(url: string, type: 'HTTP' | 'WS'): Promise<RpcLatency> {
  const transport = type === 'WS' 
    ? webSocket(url)
    : http(url, { timeout: 10000 })
  
  const client = createPublicClient({
    chain: beraChain,
    transport,
  })

  const result: RpcLatency = {
    url,
    type,
    blockNumberLatency: 0,
    callLatency: 0,
    avgLatency: 0,
    success: false,
  }

  try {
    // Test 1: eth_blockNumber
    const blockStart = Date.now()
    await client.getBlockNumber()
    result.blockNumberLatency = Date.now() - blockStart

    // Test 2: eth_call (read contract)
    const callStart = Date.now()
    await client.readContract({
      address: '0x111111111fd1a588bdb8254e3af1fc2fb0d9078a' as const,
      abi: [{ name: 'paused', type: 'function', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'bool' }] }],
      functionName: 'paused',
    })
    result.callLatency = Date.now() - callStart

    result.avgLatency = (result.blockNumberLatency + result.callLatency) / 2
    result.success = true

    // Close WS connection if needed
    if (type === 'WS' && 'transport' in client && typeof (client.transport as any).close === 'function') {
      ;(client.transport as any).close()
    }
  } catch (error: any) {
    result.error = error.message || String(error)
    result.success = false
  }

  return result
}

async function main() {
  console.log('🔍 Phase 4: RPC Latency Probe\n')
  console.log('='.repeat(80))

  // Get RPCs from env or use defaults
  const rpcsHttpEnv = process.env.RPCS_HTTP || ''
  const rpcsWsEnv = process.env.RPCS_WS || ''

  const rpcsHttp = rpcsHttpEnv.split(',').map(s => s.trim()).filter(Boolean)
  const rpcsWs = rpcsWsEnv.split(',').map(s => s.trim()).filter(Boolean)

  if (rpcsHttp.length === 0 && rpcsWs.length === 0) {
    console.error('❌ No RPCs configured. Set RPCS_HTTP and/or RPCS_WS in .env')
    process.exit(1)
  }

  console.log(`Testing ${rpcsHttp.length} HTTP RPCs and ${rpcsWs.length} WS RPCs...\n`)

  const allResults: RpcLatency[] = []

  // Probe HTTP RPCs
  for (const rpc of rpcsHttp) {
    console.log(`Probing HTTP: ${rpc}...`)
    const result = await probeRpcLatency(rpc, 'HTTP')
    allResults.push(result)
    if (result.success) {
      console.log(`  ✅ BlockNumber: ${result.blockNumberLatency}ms, Call: ${result.callLatency}ms, Avg: ${result.avgLatency.toFixed(1)}ms`)
    } else {
      console.log(`  ❌ Failed: ${result.error}`)
    }
  }

  // Probe WS RPCs
  for (const rpc of rpcsWs) {
    console.log(`Probing WS: ${rpc}...`)
    const result = await probeRpcLatency(rpc, 'WS')
    allResults.push(result)
    if (result.success) {
      console.log(`  ✅ BlockNumber: ${result.blockNumberLatency}ms, Call: ${result.callLatency}ms, Avg: ${result.avgLatency.toFixed(1)}ms`)
    } else {
      console.log(`  ❌ Failed: ${result.error}`)
    }
  }

  // Sort by average latency
  const successful = allResults.filter(r => r.success).sort((a, b) => a.avgLatency - b.avgLatency)
  const failed = allResults.filter(r => !r.success)

  console.log('\n' + '='.repeat(80))
  console.log('📊 RPC LATENCY RANKING (fastest first)')
  console.log('='.repeat(80))

  if (successful.length === 0) {
    console.error('❌ All RPCs failed!')
    process.exit(1)
  }

  console.log('\n✅ Successful RPCs:')
  successful.forEach((rpc, idx) => {
    console.log(`  ${idx + 1}. ${rpc.type.padEnd(4)} ${rpc.url.padEnd(60)} Avg: ${rpc.avgLatency.toFixed(1)}ms`)
  })

  if (failed.length > 0) {
    console.log('\n❌ Failed RPCs:')
    failed.forEach(rpc => {
      console.log(`  - ${rpc.type.padEnd(4)} ${rpc.url.padEnd(60)} Error: ${rpc.error}`)
    })
  }

  console.log('\n' + '='.repeat(80))
  console.log('💡 Recommended .env configuration:')
  console.log('='.repeat(80))
  
  const httpSorted = successful.filter(r => r.type === 'HTTP').map(r => r.url)
  const wsSorted = successful.filter(r => r.type === 'WS').map(r => r.url)

  console.log('\nRPCS_HTTP=' + httpSorted.join(','))
  if (wsSorted.length > 0) {
    console.log('RPCS_WS=' + wsSorted.join(','))
  }

  console.log('\n✅ Latency probe complete')
}

main().catch((error) => {
  console.error('Fatal error:', error)
  process.exit(1)
})