Telegram Bot para Alertas de Value Bets:

mkdir value-bet-bot && cd value-bet-bot
npm init -y
npm install telegraf axios dotenv node-cron
npm install -D typescript @types/node tsx
npx tsc --init

// src/config.ts
import dotenv from 'dotenv';
dotenv.config();

export const config = {
  telegram: {
    token: process.env.TELEGRAM_TOKEN!,
    chatId: process.env.TELEGRAM_CHAT_ID!,
  },
  oddsApi: {
    key: process.env.ODDS_API_KEY!,
    baseUrl: 'https://api.the-odds-api.com/v4',
  },
  // Configurações de detecção
  detection: {
    minEdge: 0.03,        // edge mínimo de 3% pra alertar
    refBookmaker: 'pinnacle', // casa de referência
    pollInterval: '*/5 * * * *', // a cada 5 minutos
    sports: [
      'soccer_brazil_campeonato',
      'soccer_epl',
      'soccer_spain_la_liga',
    ],
  },
};

// src/services/odds-api.ts
import axios from 'axios';
import { config } from '../config';

export interface BookmakerOdds {
  gameId: string;
  homeTeam: string;
  awayTeam: string;
  commenceTime: string;
  bookmaker: string;
  oddHome: number;
  oddAway: number;
  oddDraw: number;
}

interface ApiGame {
  id: string;
  home_team: string;
  away_team: string;
  commence_time: string;
  bookmakers: Array<{
    key: string;
    markets: Array<{
      key: string;
      outcomes: Array<{ name: string; price: number }>;
    }>;
  }>;
}

export async function fetchOdds(sport: string): Promise<BookmakerOdds[]> {
  const { data } = await axios.get<ApiGame[]>(
    `${config.oddsApi.baseUrl}/sports/${sport}/odds`,
    {
      params: {
        apiKey: config.oddsApi.key,
        regions: 'eu',
        markets: 'h2h',
        oddsFormat: 'decimal',
      },
    }
  );

  const results: BookmakerOdds[] = [];

  for (const game of data) {
    for (const bookmaker of game.bookmakers) {
      const h2h = bookmaker.markets.find(m => m.key === 'h2h');
      if (!h2h) continue;

      const outcomes = Object.fromEntries(
        h2h.outcomes.map(o => [o.name, o.price])
      );

      results.push({
        gameId: game.id,
        homeTeam: game.home_team,
        awayTeam: game.away_team,
        commenceTime: game.commence_time,
        bookmaker: bookmaker.key,
        oddHome: outcomes[game.home_team] ?? 0,
        oddAway: outcomes[game.away_team] ?? 0,
        oddDraw: outcomes['Draw'] ?? 0,
      });
    }
  }

  return results;
}

export async function fetchAllSports(): Promise<BookmakerOdds[]> {
  const allOdds: BookmakerOdds[] = [];

  for (const sport of config.detection.sports) {
    try {
      const odds = await fetchOdds(sport);
      allOdds.push(...odds);
      // Respeita rate limit da API
      await new Promise(resolve => setTimeout(resolve, 1000));
    } catch (err) {
      console.error(`Erro ao buscar ${sport}:`, err);
    }
  }

  return allOdds;
}

// src/services/value-detector.ts
import { BookmakerOdds } from './odds-api';
import { config } from '../config';

export interface ValueBet {
  gameId: string;
  homeTeam: string;
  awayTeam: string;
  commenceTime: string;
  bookmaker: string;
  outcome: 'home' | 'away' | 'draw';
  oddOffered: number;
  oddPinnacle: number;
  edge: number; // percentual
  impliedProb: number; // prob implícita da Pinnacle
}

export function detectValueBets(odds: BookmakerOdds[]): ValueBet[] {
  const { minEdge, refBookmaker } = config.detection;
  const valueBets: ValueBet[] = [];

  // Agrupa por jogo
  const byGame = new Map<string, BookmakerOdds[]>();
  for (const o of odds) {
    const list = byGame.get(o.gameId) || [];
    list.push(o);
    byGame.set(o.gameId, list);
  }

  for (const [gameId, gameOdds] of byGame) {
    const ref = gameOdds.find(o => o.bookmaker === refBookmaker);
    if (!ref) continue; // sem Pinnacle, pula

    for (const o of gameOdds) {
      if (o.bookmaker === refBookmaker) continue;

      // Compara cada outcome
      const comparisons: Array<{
        outcome: 'home' | 'away' | 'draw';
        offered: number;
        reference: number;
      }> = [
        { outcome: 'home', offered: o.oddHome, reference: ref.oddHome },
        { outcome: 'away', offered: o.oddAway, reference: ref.oddAway },
        { outcome: 'draw', offered: o.oddDraw, reference: ref.oddDraw },
      ];

      for (const { outcome, offered, reference } of comparisons) {
        if (!offered || !reference || reference <= 1) continue;

        const edge = (offered / reference) - 1;

        if (edge >= minEdge) {
          valueBets.push({
            gameId,
            homeTeam: o.homeTeam,
            awayTeam: o.awayTeam,
            commenceTime: o.commenceTime,
            bookmaker: o.bookmaker,
            outcome,
            oddOffered: offered,
            oddPinnacle: reference,
            edge: Math.round(edge * 10000) / 100, // ex: 4.52%
            impliedProb: Math.round((1 / reference) * 10000) / 100,
          });
        }
      }
    }
  }

  return valueBets.sort((a, b) => b.edge - a.edge);
}

// src/bot.ts
import { Telegraf } from 'telegraf';
import cron from 'node-cron';
import { config } from './config';
import { fetchAllSports } from './services/odds-api';
import { detectValueBets, ValueBet } from './services/value-detector';

const bot = new Telegraf(config.telegram.token);
let isRunning = true;
let lastScan = new Date();
let totalAlerts = 0;

function formatValueBetMessage(vb: ValueBet): string {
  const outcomeLabel = {
    home: `Vitoria ${vb.homeTeam}`,
    away: `Vitoria ${vb.awayTeam}`,
    draw: 'Empate',
  }[vb.outcome];

  const gameTime = new Date(vb.commenceTime).toLocaleString('pt-BR', {
    day: '2-digit', month: '2-digit',
    hour: '2-digit', minute: '2-digit',
  });

  return [
    `VALUE BET DETECTADO`,
    ``,
    `${vb.homeTeam} x ${vb.awayTeam}`,
    `Horario: ${gameTime}`,
    ``,
    `Aposta: ${outcomeLabel}`,
    `Casa: ${vb.bookmaker}`,
    `Odd oferecida: ${vb.oddOffered.toFixed(2)}`,
    `Odd Pinnacle: ${vb.oddPinnacle.toFixed(2)}`,
    `Edge: ${vb.edge.toFixed(1)}%`,
    `Prob implicita: ${vb.impliedProb.toFixed(1)}%`,
  ].join('\n');
}

async function scan() {
  if (!isRunning) return;

  console.log(`[${new Date().toISOString()}] Escaneando odds...`);
  lastScan = new Date();

  try {
    const odds = await fetchAllSports();
    const valueBets = detectValueBets(odds);

    console.log(`  ${odds.length} odds coletadas, ${valueBets.length} value bets encontrados`);

    // Envia top 5 pra não spammar
    const toSend = valueBets.slice(0, 5);

    for (const vb of toSend) {
      const message = formatValueBetMessage(vb);
      await bot.telegram.sendMessage(config.telegram.chatId, message);
      totalAlerts++;
      // Delay entre mensagens pra não bater rate limit do Telegram
      await new Promise(r => setTimeout(r, 500));
    }

    if (toSend.length > 0) {
      await bot.telegram.sendMessage(
        config.telegram.chatId,
        `Total: ${valueBets.length} value bets. Mostrando top ${toSend.length} por edge.`
      );
    }
  } catch (err) {
    console.error('Erro no scan:', err);
  }
}

// Comandos do bot
bot.command('status', (ctx) => {
  ctx.reply([
    `Bot: ${isRunning ? 'Ativo' : 'Pausado'}`,
    `Ultimo scan: ${lastScan.toLocaleString('pt-BR')}`,
    `Alertas enviados: ${totalAlerts}`,
    `Ligas monitoradas: ${config.detection.sports.length}`,
    `Edge minimo: ${config.detection.minEdge * 100}%`,
  ].join('\n'));
});

bot.command('scan', async (ctx) => {
  await ctx.reply('Iniciando scan manual...');
  await scan();
  await ctx.reply('Scan concluido.');
});

bot.command('pause', (ctx) => {
  isRunning = false;
  ctx.reply('Monitoramento pausado. Use /resume pra retomar.');
});

bot.command('resume', (ctx) => {
  isRunning = true;
  ctx.reply('Monitoramento retomado.');
});

bot.command('help', (ctx) => {
  ctx.reply([
    'Comandos disponiveis:',
    '/status - Status atual do bot',
    '/scan - Forca scan imediato',
    '/pause - Pausa o monitoramento',
    '/resume - Retoma o monitoramento',
    '/help - Mostra esta mensagem',
  ].join('\n'));
});

// Agenda o polling
cron.schedule(config.detection.pollInterval, scan);

// Inicia
bot.launch();
console.log('Bot iniciado. Aguardando scans...');

// Graceful shutdown
process.once('SIGINT', () => bot.stop('SIGINT'));
process.once('SIGTERM', () => bot.stop('SIGTERM'));