Building a Poker Bot for TON Telegram Apps: A Developer's Field Guide

const stakeLevels = {
  micro: {
    blinds: [0.01, 0.02],
    minBuyIn: 1,
    maxBuyIn: 5,
    activeHours: "always" // 24/7 liquidity
  },
  low: {
    blinds: [0.10, 0.25],
    minBuyIn: 10,
    maxBuyIn: 40,
    activeHours: "peak+4" // 4 hours around UTC evening
  },
  mid: {
    blinds: [0.50, 1.00],
    minBuyIn: 50,
    maxBuyIn: 200,
    activeHours: "peak" // UTC 18:00-22:00
  },
  high: {
    blinds: [2.00, 5.00],
    minBuyIn: 200,
    maxBuyIn: 1000,
    activeHours: "variable" // Depends on player pool
  }
};

const WebSocket = require('ws');

class TONPokerScanner {
  constructor(appEndpoint) {
    this.ws = new WebSocket(appEndpoint);
    this.tables = new Map();
  }

  connect() {
    this.ws.on('message', (data) => {
      const payload = JSON.parse(data.toString());

      if (payload.type === 'table_update') {
        this.processTable(payload.table);
      }

      if (payload.type === 'table_close') {
        this.tables.delete(payload.tableId);
      }
    });

    // Subscribe to all stake levels
    this.ws.send(JSON.stringify({
      action: 'subscribe',
      channels: ['tables:*']
    }));
  }

  processTable(table) {
    const key = `${table.gameType}:${table.blinds}`;

    if (!this.tables.has(key)) {
      this.tables.set(key, {
        count: 0,
        avgPlayers: 0,
        lastSeen: Date.now()
      });
    }

    const entry = this.tables.get(key);
    entry.count++;
    entry.avgPlayers = (entry.avgPlayers + table.players) / 2;
  }

  getStakeReport(stakeLevel) {
    const report = {};
    for (const [key, data] of this.tables) {
      if (key.includes(stakeLevel)) {
        report[key] = data;
      }
    }
    return report;
  }
}

// Usage
const scanner = new TONPokerScanner('wss://api.tonpoker.app/tables');
scanner.connect();

class HandHistoryParser {
  constructor(rawData) {
    this.hands = this.parseBatch(rawData);
  }

  parseBatch(data) {
    return data.hands.map(hand => ({
      id: hand.id,
      gameType: hand.game_type, // 'holdem', 'omaha', 'short_deck'
      blinds: hand.blinds,
      players: hand.players.map(p => ({
        id: p.id,
        position: p.seat,
        stack: p.stack_at_start,
        vpip: this.calculateVPIP(p.actions)
      })),
      actions: this.parseActions(hand.actions),
      showdown: hand.showdown || null
    }));
  }

  calculateVPIP(actions) {
    if (!actions || actions.length === 0) return 0;

    const preflopActions = actions.filter(a => a.street === 'preflop');
    const voluntaryCallsOrRaises = preflopActions.filter(a => 
      (a.type === 'call' && a.facing_bet > 0) || 
      a.type === 'raise'
    );

    return (voluntaryCallsOrRaises.length / preflopActions.length) * 100;
  }

  parseActions(actions) {
    return actions.map(action => ({
      street: action.street,
      player: action.player_id,
      type: action.action_type, // 'fold', 'check', 'call', 'raise', 'all_in'
      amount: action.amount || 0,
      timestamp: action.timestamp
    }));
  }
}

class GameSelectionAnalyzer {
  constructor(sessionHistory) {
    this.sessions = sessionHistory;
  }

  calculateWinRateByStake() {
    const stats = {};

    for (const session of this.sessions) {
      const key = `${session.gameType}:${session.blinds}`;

      if (!stats[key]) {
        stats[key] = {
          sessions: 0,
          totalProfit: 0,
          totalHours: 0,
          bbPer100: 0
        };
      }

      const entry = stats[key];
      entry.sessions++;
      entry.totalProfit += session.profit;
      entry.totalHours += session.duration_hours;

      // Calculate big blinds per 100 hands
      const handsPlayed = session.hands_played || 100;
      const bigBlind = session.blinds[1]; // Big blind is second element
      entry.bbPer100 = (session.profit / bigBlind) * (100 / handsPlayed);
    }

    return stats;
  }

  findOptimalStakes() {
    const stats = this.calculateWinRateByStake();

    return Object.entries(stats)
      .filter(([_, data]) => data.sessions >= 10) // Minimum sample
      .sort((a, b) => b[1].bbPer100 - a[1].bbPer100)
      .map(([key, data]) => ({
        game: key,
        winRate: data.bbPer100.toFixed(2),
        confidence: Math.min(data.sessions / 50, 1) // Scale to 0-1
      }));
  }
}

# 1. Scan for active tables
node scanner.js --output tables.json

# 2. Download hand histories from profitable tables
python fetch_hands.py --tables tables.json --output hands/

# 3. Calculate stats and generate report
node analyze.js --hands hands/ --report report.md

# 4. Send digest via Telegram
python notify.py --report report.md