feat: odds calculation engine — ELO-based betting odds with house edge

Converts ELO ratings + streaks + recent form into betting odds.
Supports decimal, fractional, and American formats.
Includes bet validation, payout calculation, and 27 tests.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

server/src/engine/odds.test.ts

@@ -0,0 +1,151 @@
+import { describe, it, expect } from 'vitest'
+import {
+  eloProbability,
+  calculateOdds,
+  oddsToFractional,
+  oddsToAmerican,
+  calculatePayout,
+  validateBet,
+} from './odds.js'
+
+describe('eloProbability', () => {
+  it('equal ELO gives 50/50', () => {
+    expect(eloProbability(1200, 1200)).toBeCloseTo(0.5, 5)
+  })
+
+  it('higher ELO favored', () => {
+    expect(eloProbability(1400, 1200)).toBeGreaterThan(0.7)
+  })
+
+  it('lower ELO underdog', () => {
+    expect(eloProbability(1000, 1400)).toBeLessThan(0.15)
+  })
+
+  it('probabilities are complementary', () => {
+    const pA = eloProbability(1300, 1100)
+    const pB = eloProbability(1100, 1300)
+    expect(pA + pB).toBeCloseTo(1, 5)
+  })
+
+  it('extreme ELO difference stays finite', () => {
+    const p = eloProbability(100, 2500)
+    expect(p).toBeGreaterThan(0)
+    expect(p).toBeLessThan(0.001)
+    expect(isFinite(p)).toBe(true)
+  })
+})
+
+describe('calculateOdds', () => {
+  it('equal ELO gives near-even odds', () => {
+    const odds = calculateOdds(1200, 1200)
+    expect(odds.botAWinProb).toBeCloseTo(0.5, 1)
+    expect(odds.botBWinProb).toBeCloseTo(0.5, 1)
+    expect(odds.botADecimalOdds).toBeCloseTo(2.0, 0)
+  })
+
+  it('house edge reduces payout below fair odds', () => {
+    const odds = calculateOdds(1200, 1200, { houseEdge: 0.05 })
+    expect(odds.botAPayoutMultiplier).toBeLessThan(odds.botADecimalOdds)
+    expect(odds.botBPayoutMultiplier).toBeLessThan(odds.botBDecimalOdds)
+  })
+
+  it('favorite has lower payout multiplier', () => {
+    const odds = calculateOdds(1500, 1200)
+    expect(odds.botAPayoutMultiplier).toBeLessThan(odds.botBPayoutMultiplier)
+  })
+
+  it('streak adjusts probability', () => {
+    const noStreak = calculateOdds(1200, 1200)
+    const withStreak = calculateOdds(1200, 1200, { streakA: 5 })
+    expect(withStreak.botAWinProb).toBeGreaterThan(noStreak.botAWinProb)
+  })
+
+  it('probabilities always sum to 1', () => {
+    const odds = calculateOdds(1600, 1000, { streakA: 3, streakB: 1 })
+    expect(odds.botAWinProb + odds.botBWinProb).toBeCloseTo(1, 2)
+  })
+
+  it('probabilities capped between 2% and 98%', () => {
+    const odds = calculateOdds(3000, 500, { streakA: 5 })
+    expect(odds.botAWinProb).toBeLessThanOrEqual(0.98)
+    expect(odds.botBWinProb).toBeGreaterThanOrEqual(0.02)
+  })
+
+  it('spread reflects ELO difference', () => {
+    const odds = calculateOdds(1500, 1200)
+    expect(odds.spread).toBe(300)
+  })
+})
+
+describe('oddsToFractional', () => {
+  it('even money', () => {
+    expect(oddsToFractional(2.0)).toBe('1/1')
+  })
+
+  it('3/1', () => {
+    expect(oddsToFractional(4.0)).toBe('3/1')
+  })
+
+  it('1/2', () => {
+    expect(oddsToFractional(1.5)).toBe('1/2')
+  })
+})
+
+describe('oddsToAmerican', () => {
+  it('underdog shows positive', () => {
+    expect(oddsToAmerican(3.0)).toBe('+200')
+  })
+
+  it('favorite shows negative', () => {
+    expect(oddsToAmerican(1.5)).toBe('-200')
+  })
+
+  it('even money', () => {
+    expect(oddsToAmerican(2.0)).toBe('+100')
+  })
+})
+
+describe('calculatePayout', () => {
+  it('100 sats at 2x = 200', () => {
+    expect(calculatePayout(100, 2.0)).toBe(200)
+  })
+
+  it('floors to integer sats', () => {
+    expect(calculatePayout(100, 1.94)).toBe(194)
+  })
+})
+
+describe('validateBet', () => {
+  it('valid bet', () => {
+    expect(validateBet(1000).valid).toBe(true)
+  })
+
+  it('below minimum', () => {
+    const r = validateBet(50)
+    expect(r.valid).toBe(false)
+    expect(r.error).toContain('Minimum')
+  })
+
+  it('above maximum', () => {
+    const r = validateBet(200_000)
+    expect(r.valid).toBe(false)
+    expect(r.error).toContain('Maximum')
+  })
+
+  it('zero is invalid', () => {
+    expect(validateBet(0).valid).toBe(false)
+  })
+
+  it('negative is invalid', () => {
+    expect(validateBet(-100).valid).toBe(false)
+  })
+
+  it('non-integer is invalid', () => {
+    expect(validateBet(100.5).valid).toBe(false)
+  })
+
+  it('custom limits', () => {
+    expect(validateBet(50, 10, 100).valid).toBe(true)
+    expect(validateBet(5, 10, 100).valid).toBe(false)
+  })
+})