check-mint-timing-pattern.ts

/**
 * Check mint timing patterns - specifically looking for "11 minutes after the hour" pattern
 * Uses Beratrail API to get successful mint transactions
 */

import 'dotenv/config'
import { writeFileSync } from 'fs'
import { createPublicClient, http, parseAbi } from 'viem'
import { beraChain } from './config.js'

const MITEDDY_CONTRACT = '0x111111111fd1a588bdb8254e3af1fc2fb0d9078a' as const
const TRANSFER_ABI = parseAbi([
  'event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)',
])

interface MintEvent {
  txHash: string
  blockNumber: number
  blockTimestamp: number
  blockTimeMs: number
  minutesAfterHour: number
  timeString: string
}

async function getMintEventsFromRPC(client: ReturnType<typeof createPublicClient>, fromBlock: bigint, toBlock: bigint): Promise<any[]> {
  const BATCH_SIZE = 10000n
  const allEvents: any[] = []
  
  let currentFrom = fromBlock
  let batchNum = 1
  
  while (currentFrom <= toBlock) {
    const currentTo = currentFrom + BATCH_SIZE - 1n > toBlock 
      ? toBlock 
      : currentFrom + BATCH_SIZE - 1n
    
    try {
      const events = await client.getLogs({
        address: MITEDDY_CONTRACT,
        event: TRANSFER_ABI[0],
        fromBlock: currentFrom,
        toBlock: currentTo,
      })
      allEvents.push(...events)
      console.log(`  Batch ${batchNum}: Blocks ${currentFrom}-${currentTo} - Found ${events.length} events`)
    } catch (error: any) {
      console.log(`  Batch ${batchNum}: Error - ${error.message}`)
    }
    
    currentFrom = currentTo + 1n
    batchNum++
    
    if (currentFrom <= toBlock) {
      await new Promise(resolve => setTimeout(resolve, 200))
    }
  }
  
  return allEvents
}

async function checkMintTimingPattern() {
  console.log('🔍 Checking Mint Timing Patterns\n')
  console.log('='.repeat(80))
  console.log(`Analyzing successful mints from MiTeddy contract: ${MITEDDY_CONTRACT}\n`)

  // Use public RPCs
  const publicRPCs = [
    'https://rpc.berachain.com',
    'https://berachain-rpc.publicnode.com',
    'https://berachain.drpc.org',
  ]

  let client: ReturnType<typeof createPublicClient>
  let rpcUsed = ''

  for (const rpc of publicRPCs) {
    try {
      const testClient = createPublicClient({
        chain: beraChain,
        transport: http(rpc, { timeout: 10000 }),
      })
      await testClient.getBlockNumber()
      client = testClient
      rpcUsed = rpc
      break
    } catch (e) {
      continue
    }
  }

  if (!client!) {
    throw new Error('Failed to connect to any RPC')
  }

  console.log(`📡 Using RPC: ${rpcUsed}\n`)

  // Get current block
  const currentBlock = await client.getBlockNumber()
  console.log(`Current block: ${currentBlock}\n`)

  // Search last 50,000 blocks (roughly 2-3 days)
  const searchRange = 50000n
  const fromBlock = currentBlock - searchRange

  console.log(`Searching blocks ${fromBlock} to ${currentBlock} for Transfer events...\n`)

  // Get Transfer events (batched to respect 10,000 block limit)
  const transferEvents = await getMintEventsFromRPC(client, fromBlock, currentBlock)

  console.log(`\nFound ${transferEvents.length} total Transfer events\n`)

  // Filter for mints (Transfer from zero address)
  const mints: MintEvent[] = []
  
  for (const event of transferEvents) {
    // Check if this is a mint (from zero address)
    if (event.args.from?.toLowerCase() === '0x0000000000000000000000000000000000000000') {
      // Get block to get timestamp
      const block = await client.getBlock({ blockNumber: event.blockNumber })
      const blockTimeMs = Number(block.timestamp) * 1000
      const date = new Date(blockTimeMs)
      
      // Calculate minutes after the hour
      const minutesAfterHour = date.getUTCMinutes()
      
      mints.push({
        txHash: event.transactionHash,
        blockNumber: Number(event.blockNumber),
        blockTimestamp: Number(block.timestamp),
        blockTimeMs,
        minutesAfterHour,
        timeString: date.toISOString(),
      })
    }
  }

  console.log(`✅ Found ${mints.length} successful mints\n`)

  if (mints.length === 0) {
    console.log('No mints found in the search range.')
    return
  }

  // Analyze timing patterns
  console.log('='.repeat(80))
  console.log('📊 MINT TIMING ANALYSIS\n')

  // Group by minutes after hour
  const minutesDistribution: { [key: number]: number } = {}
  mints.forEach(m => {
    minutesDistribution[m.minutesAfterHour] = (minutesDistribution[m.minutesAfterHour] || 0) + 1
  })

  console.log('Mints by Minutes After Hour:')
  const sortedMinutes = Object.entries(minutesDistribution)
    .map(([min, count]) => ({ minute: parseInt(min), count }))
    .sort((a, b) => b.count - a.count)

  sortedMinutes.forEach(({ minute, count }) => {
    const bar = '█'.repeat(count)
    console.log(`  ${minute.toString().padStart(2)} minutes: ${bar} (${count})`)
  })

  // Check specifically for 11 minutes pattern
  const mintsAt11 = mints.filter(m => m.minutesAfterHour === 11)
  console.log(`\n🎯 Mints at 11 minutes after the hour: ${mintsAt11.length}/${mints.length}`)
  
  if (mintsAt11.length > 0) {
    const percentage = (mintsAt11.length / mints.length) * 100
    console.log(`   Percentage: ${percentage.toFixed(1)}%`)
    console.log(`\n   Examples:`)
    mintsAt11.slice(0, 5).forEach(m => {
      const date = new Date(m.blockTimeMs)
      console.log(`     ${date.toISOString()} (Block ${m.blockNumber})`)
    })
  }

  // Show all mints with their timing
  console.log(`\n📋 All Successful Mints:`)
  mints.sort((a, b) => Number(a.blockNumber) - Number(b.blockNumber))
  mints.forEach((m, idx) => {
    const date = new Date(m.blockTimeMs)
    const timeStr = date.toISOString().substring(11, 19)
    const dateStr = date.toISOString().substring(0, 10)
    console.log(`  ${(idx + 1).toString().padStart(2)}. ${dateStr} ${timeStr} UTC (${m.minutesAfterHour} min after hour) - Block ${m.blockNumber}`)
  })

  // Calculate average minutes after hour
  const avgMinutes = mints.reduce((sum, m) => sum + m.minutesAfterHour, 0) / mints.length
  console.log(`\n📊 Average minutes after hour: ${avgMinutes.toFixed(1)}`)

  // Check if pattern is consistent
  const percentage = mintsAt11.length > 0 ? (mintsAt11.length / mints.length) * 100 : 0
  if (mintsAt11.length >= mints.length * 0.5) {
    console.log(`\n✅ STRONG PATTERN: ${percentage.toFixed(1)}% of mints occur at 11 minutes after the hour!`)
    console.log(`   This suggests the unlock time is consistently at XX:11:XX`)
  } else if (mintsAt11.length > 0) {
    console.log(`\n⚠️  Some mints at 11 minutes, but not a strong pattern`)
  }

  // Save results
  const results = {
    totalMints: mints.length,
    mintsAt11Minutes: mintsAt11.length,
    percentageAt11: mintsAt11.length > 0 ? (mintsAt11.length / mints.length) * 100 : 0,
    averageMinutesAfterHour: avgMinutes,
    minutesDistribution,
    allMints: mints.map(m => ({
      txHash: m.txHash,
      blockNumber: m.blockNumber.toString(),
      timestamp: m.timeString,
      minutesAfterHour: m.minutesAfterHour,
    })),
  }

  const fs = await import('fs')
  fs.writeFileSync('mint-timing-analysis.json', JSON.stringify(results, null, 2))
  console.log(`\n💾 Results saved to mint-timing-analysis.json`)
}

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