@devrongx/games 0.1.0

package/src/games/prematch-bets/config.ts

@@ -0,0 +1,604 @@
+// @devrongx/games — games/prematch-bets/config.ts
+// Pure types, config, and calculation functions for the IPL prediction betting system.
+// Everything is driven by IChallengeConfig — the single JSON object that will come from APIs later.
+// Leaderboard pool is generated deterministically from a seed string via seedrandom.
+
+import seedrandom from "seedrandom";
+
+// ────── Types ──────
+
+export interface IChallengeOption {
+    label: string;
+    odds: number;    // Decimal odds (e.g., 1.40 = 40% profit, 3.2 = 220% profit)
+    entry: number;   // Points to bet on this option
+    risk: number;    // Admin-set risk contribution 0–100. Lower odds → lower risk. Weighted by bet amount.
+}
+
+export interface IChallengeMarket {
+    id: string;
+    question: string;
+    icon: string;
+    accent: string;
+    category: string;   // "toss" | "match" | "csk_innings" | "rcb_innings" | "match_level"
+    options: IChallengeOption[];
+    userBet?: IBetEntry; // Present when API returns a logged-in user's saved bet for this market
+}
+
+export interface IChallengeTeam {
+    name: string;        // "Chennai"
+    shortName: string;   // "CSK"
+    logo: string;        // "/ipl/csk.png"
+    gradient: string;    // "linear-gradient(180deg, #FFF02C 0%, #DF9901 100%)"
+}
+
+export interface IChallengeGame {
+    id: string;              // Popup/route identifier ("pre-match", "ball-sequence", "fantasy-11")
+    title: string;           // Card heading ("Pre-Match Bets")
+    desc: string;            // Card description
+    tag: string;             // Badge label ("STRATEGY", "LIVE ACTION", "SKILL BASED")
+    icon: string;            // Key into a UI-side icon map ("stadium", "ball", "fantasy")
+}
+
+export interface IChallengeSection {
+    type: "info" | "challenge";
+    title: string;
+    content: string;
+}
+
+export interface IRankBracket {
+    from: number;        // Inclusive start rank
+    to: number;          // Inclusive end rank
+    poolPercent: number; // Total % of prize pool shared equally among ranks in this bracket
+}
+
+export interface IChallengeConfig {
+    id: string;
+    title: string;
+    matchTitle: string;
+    tag: string;
+    teamA: IChallengeTeam;
+    teamB: IChallengeTeam;
+    venue: string;                       // "M. Chinnaswamy Stadium, Bengaluru"
+    bannerImage: string;                 // Match-specific background image path
+    playerImages: [string, string];      // [player1, player2] images for banner
+    opponents: IChallengeTeam[];         // Cycling opponent list for homepage animation
+    matchStartTime: string;              // ISO 8601 datetime for match start
+    startingBalance: number;
+    entryFee: number;                    // USDC entry fee per player
+    totalEntries: number;                // Total players in the pool (drives prize pool calc)
+    rakePercent: number;                 // Platform cut, 0–1 (e.g., 0.20 = 20%)
+    rankBrackets: IRankBracket[];        // Prize pool distribution by rank bracket
+    leaderboardSeed: string;             // Deterministic seed for fake pool generation
+    compoundMultipliers: number[];       // Index = number of active bets
+    parlayConfig: IParlayConfig;         // Combined bet configuration
+    categoryLabels: Record<string, string>;  // Display names for market categories (keyed by market.category)
+    games: IChallengeGame[];             // Game modes for this match (cards on homepage)
+    markets: IChallengeMarket[];
+    sections: IChallengeSection[];
+}
+
+export interface ILeaderboardEntry {
+    wallet: string;
+    pts: number;
+    payout: number;
+    isYou: boolean;
+    rank?: number;        // Actual rank among totalEntries (pool-based leaderboards)
+    gapAbove?: boolean;   // Visual separator — there are hidden ranks above this row
+}
+
+export interface IParlayConfig {
+    maxSlots: number;         // Max combined bet groups (6)
+    minLegs: number;          // Minimum questions to combine (2)
+    maxLegs: number;          // Max questions per parlay
+    colors: string[];         // Distinct color per slot
+    defaultStake: number;     // Default points per parlay leg
+    stakeIncrements: number;  // Picker step size
+}
+
+// ── Unified bet state ──
+// Single source of truth for all user selections: option picks, bet amounts, and parlay grouping.
+// parlaySlot = null means individual bet. parlaySlot = 0–5 means part of that combined bet group.
+export interface IBetEntry {
+    optionIdx: number;
+    amount: number;           // 0 = option picked but no points committed yet
+    parlaySlot: number | null; // null = individual, 0–5 = combined bet group
+}
+export type IUserBets = Record<number, IBetEntry>;  // mIdx → entry
+
+// ── Derived helpers (computed from IUserBets, not stored) ──
+
+/** Extract parlay groups: slot → [mIdx, ...]. Only includes slots with entries. */
+export function deriveParlayGroups(bets: IUserBets): Record<number, number[]> {
+    const groups: Record<number, number[]> = {};
+    for (const [mIdxStr, entry] of Object.entries(bets)) {
+        if (entry.parlaySlot !== null) {
+            (groups[entry.parlaySlot] ??= []).push(Number(mIdxStr));
+        }
+    }
+    return groups;
+}
+
+/** Inverse lookup: mIdx → parlaySlot (only for markets actually in a parlay). */
+export function deriveMarketToParlay(bets: IUserBets): Record<number, number> {
+    const map: Record<number, number> = {};
+    for (const [mIdxStr, entry] of Object.entries(bets)) {
+        if (entry.parlaySlot !== null) map[Number(mIdxStr)] = entry.parlaySlot;
+    }
+    return map;
+}
+
+/** Initialize local bet state from config — picks up any saved user bets the API returned inline on markets. */
+export function extractUserBets(config: IChallengeConfig): IUserBets {
+    const bets: IUserBets = {};
+    config.markets.forEach((m, i) => {
+        if (m.userBet) bets[i] = m.userBet;
+    });
+    return bets;
+}
+
+export interface IBetSummary {
+    selectedCount: number;
+    compoundMultiplier: number;
+    totalEntry: number;
+    baseReward: number;
+    compoundedReward: number;
+    remainingBalance: number;
+    potentialBalance: number;
+    riskPercent: number;         // Weighted risk 0–100 from config risk values
+}
+
+export interface IMiniLeaderboard {
+    rank: number;
+    you: ILeaderboardEntry;
+    above: ILeaderboardEntry | null;
+    below: ILeaderboardEntry | null;
+    aboveRank: number;
+    belowRank: number;
+    total: number;
+}
+
+// ────── Pool types ──────
+
+export interface IPoolData {
+    scores: number[];   // Sorted descending, length = totalEntries - 1
+    seed: string;       // For deterministic wallet generation
+}
+
+// ────── Challenge Config: CSK vs RCB ──────
+// This entire object will come from the API later. For now it's hardcoded.
+
+export const CSK_VS_RCB_CHALLENGE: IChallengeConfig = {
+    id: "csk-vs-rcb-2026-match1",
+    title: "Pre-Match Bets",
+    matchTitle: "Chennai vs Bengaluru",
+    tag: "STRATEGY",
+    teamA: { name: "Chennai", shortName: "CSK", logo: "/ipl/csk.png", gradient: "linear-gradient(180deg, #FFF02C 0%, #DF9901 100%)" },
+    teamB: { name: "Bengaluru", shortName: "RCB", logo: "/ipl/rcb.png", gradient: "linear-gradient(180deg, #191919 0%, #DB0102 100%)" },
+    venue: "M. Chinnaswamy Stadium, Bengaluru",
+    bannerImage: "/ipl/ipl-pred-bg.png",
+    playerImages: ["/ipl/ipl-pred-player1.png", "/ipl/ipl-pred-player2.png"],
+    opponents: [
+        { name: "Chennai", shortName: "CSK", logo: "/ipl/csk.png", gradient: "linear-gradient(180deg, #FFF02C 0%, #DF9901 100%)" },
+        { name: "Kolkata", shortName: "KKR", logo: "/ipl/kkr.png", gradient: "linear-gradient(180deg, #9354E5 0%, #2B0B79 100%)" },
+        { name: "Mumbai", shortName: "MI", logo: "/ipl/mi.png", gradient: "linear-gradient(180deg, #3398F3 0%, #002DAA 100%)" },
+        { name: "Hyderabad", shortName: "SRH", logo: "/ipl/srh.png", gradient: "linear-gradient(180deg, #FFBB00 0%, #FF0003 100%)" },
+        { name: "Delhi", shortName: "DC", logo: "/ipl/dc.png", gradient: "linear-gradient(180deg, #ED1B1E 0%, #0E39B4 100%)" },
+        { name: "Punjab", shortName: "PBKS", logo: "/ipl/pbks.png", gradient: "linear-gradient(180deg, #FF5356 0%, #FF0003 100%)" },
+        { name: "Gujarat", shortName: "GT", logo: "/ipl/gt.png", gradient: "linear-gradient(180deg, #2F5385 0%, #11224D 100%)" },
+        { name: "Lucknow", shortName: "LSG", logo: "/ipl/lsg.png", gradient: "linear-gradient(180deg, #FF0003 0%, #030E4A 87.98%)" },
+        { name: "Rajasthan", shortName: "RR", logo: "/ipl/rr.png", gradient: "linear-gradient(180deg, #E94098 0%, #B60153 100%)" },
+    ],
+    matchStartTime: "2026-03-28T19:30:00+05:30",
+    startingBalance: 2500,
+    entryFee: 1,
+    totalEntries: 20000,
+    rakePercent: 0.20,
+    leaderboardSeed: "csk-vs-rcb-2026-iamgame-seed-v1",
+
+    rankBrackets: [
+        { from: 1,    to: 1,     poolPercent: 0.20 },
+        { from: 2,    to: 2,     poolPercent: 0.10 },
+        { from: 3,    to: 3,     poolPercent: 0.05 },
+        { from: 4,    to: 5,     poolPercent: 0.04 },
+        { from: 6,    to: 10,    poolPercent: 0.05 },
+        { from: 11,   to: 25,    poolPercent: 0.06 },
+        { from: 26,   to: 75,    poolPercent: 0.08 },
+        { from: 76,   to: 200,   poolPercent: 0.09 },
+        { from: 201,  to: 500,   poolPercent: 0.08 },
+        { from: 501,  to: 1500,  poolPercent: 0.09 },
+        { from: 1501, to: 4000,  poolPercent: 0.10 },
+        { from: 4001, to: 6000,  poolPercent: 0.06 },
+    ],
+
+    parlayConfig: {
+        maxSlots: 6,
+        minLegs: 2,
+        maxLegs: 14,
+        colors: ["#22E3E8", "#9945FF", "#f83cc5", "#22C55E", "#f59e0b", "#3b82f6"],
+        defaultStake: 100,
+        stakeIncrements: 50,
+    },
+
+    compoundMultipliers: [
+        0, 1, 1.6, 2.5, 4, 6.5, 10, 16, 27, 43, 70, 110, 175, 280, 450,
+    ],
+
+    categoryLabels: {
+        toss: "Toss",
+        match: "Match Result",
+        csk_innings: "Chennai Innings",
+        rcb_innings: "Bengaluru Innings",
+        match_level: "Match Level",
+    },
+
+    games: [
+        {
+            id: "pre-match",
+            title: "Pre-Match Bets",
+            desc: "Toss, winner, top scorers, boundaries, wickets, MOTM. Lock in before ball one.",
+            tag: "STRATEGY",
+            icon: "stadium",
+        },
+        {
+            id: "ball-sequence",
+            title: "Ball Sequence",
+            desc: "Predict every delivery live — dot, four, six, wicket, no-ball. Bet ball-by-ball, win ball-by-ball.",
+            tag: "LIVE ACTION",
+            icon: "ball",
+        },
+        {
+            id: "fantasy-11",
+            title: "Fantasy 11 Team",
+            desc: "Draft your playing XI before the lineup drops. Outscore every other squad on the leaderboard.",
+            tag: "SKILL BASED",
+            icon: "fantasy",
+        },
+    ],
+
+    sections: [
+        {
+            type: "info",
+            title: "How It Works",
+            content: "Pick your predictions across 14 markets. Each correct pick earns points based on the odds. Stack picks for exponential parlay multipliers \u2014 up to 450x on a full sweep. Top the leaderboard, take home the prize pool.",
+        },
+        {
+            type: "challenge",
+            title: "CSK vs RCB — H2H Stats",
+            content: "Based on last 5 head-to-head matches. RCB leads 3-2. Average combined score: 372 runs. RCB won toss 3 out of 5 times.",
+        },
+    ],
+
+    markets: [
+        { id: "toss", question: "Who wins the toss?", icon: "coin", accent: "#22E3E8", category: "toss", options: [
+            { label: "Chennai", odds: 1.40, entry: 50, risk: 0 },
+            { label: "Bengaluru", odds: 1.40, entry: 50, risk: 0 },
+        ]},
+        { id: "match_result", question: "Who wins the match?", icon: "trophy", accent: "#9945FF", category: "match", options: [
+            { label: "Chennai", odds: 2.05, entry: 50, risk: 20 },
+            { label: "Bengaluru", odds: 1.75, entry: 50, risk: 12 },
+        ]},
+        { id: "csk_top_scorer", question: "Highest run scorer \u2014 Chennai?", icon: "bat", accent: "#f83cc5", category: "csk_innings", options: [
+            { label: "R Gaikwad", odds: 3.2, entry: 35, risk: 38 },
+            { label: "S Samson", odds: 3.8, entry: 30, risk: 45 },
+            { label: "S Dube", odds: 4.5, entry: 25, risk: 55 },
+            { label: "MS Dhoni", odds: 7.5, entry: 20, risk: 75 },
+            { label: "D Brevis", odds: 8.0, entry: 20, risk: 78 },
+            { label: "Others", odds: 10.0, entry: 15, risk: 85 },
+        ]},
+        { id: "csk_fours", question: "Total 4s \u2014 Chennai innings?", icon: "four", accent: "#22E3E8", category: "csk_innings", options: [
+            { label: "<10", odds: 2.6, entry: 30, risk: 30 },
+            { label: "10\u201314", odds: 1.9, entry: 40, risk: 15 },
+            { label: "15\u201318", odds: 1.6, entry: 45, risk: 8 },
+            { label: "19+", odds: 2.4, entry: 35, risk: 25 },
+        ]},
+        { id: "csk_sixes", question: "Total 6s \u2014 Chennai innings?", icon: "six", accent: "#9945FF", category: "csk_innings", options: [
+            { label: "<8", odds: 2.4, entry: 30, risk: 25 },
+            { label: "8\u201312", odds: 1.8, entry: 40, risk: 12 },
+            { label: "13\u201316", odds: 1.7, entry: 40, risk: 10 },
+            { label: "17+", odds: 2.8, entry: 25, risk: 35 },
+        ]},
+        { id: "csk_top_wicket", question: "Highest wicket-taker \u2014 Chennai?", icon: "target", accent: "#f83cc5", category: "csk_innings", options: [
+            { label: "Noor", odds: 3.4, entry: 30, risk: 40 },
+            { label: "R Chahar", odds: 3.6, entry: 30, risk: 42 },
+            { label: "Ellis", odds: 4.2, entry: 25, risk: 52 },
+            { label: "Others", odds: 5.0, entry: 20, risk: 60 },
+        ]},
+        { id: "rcb_top_scorer", question: "Highest run scorer \u2014 Bengaluru?", icon: "bat", accent: "#22E3E8", category: "rcb_innings", options: [
+            { label: "V Kohli", odds: 3.0, entry: 35, risk: 35 },
+            { label: "R Patidar", odds: 3.5, entry: 30, risk: 42 },
+            { label: "J Sharma", odds: 4.2, entry: 25, risk: 52 },
+            { label: "Others", odds: 9.0, entry: 15, risk: 82 },
+        ]},
+        { id: "rcb_fours", question: "Total 4s \u2014 Bengaluru innings?", icon: "four", accent: "#9945FF", category: "rcb_innings", options: [
+            { label: "<10", odds: 2.5, entry: 30, risk: 28 },
+            { label: "10\u201314", odds: 1.9, entry: 40, risk: 15 },
+            { label: "15\u201318", odds: 1.6, entry: 45, risk: 8 },
+            { label: "19+", odds: 2.5, entry: 30, risk: 28 },
+        ]},
+        { id: "rcb_sixes", question: "Total 6s \u2014 Bengaluru innings?", icon: "six", accent: "#f83cc5", category: "rcb_innings", options: [
+            { label: "<9", odds: 2.3, entry: 30, risk: 22 },
+            { label: "9\u201313", odds: 1.8, entry: 40, risk: 12 },
+            { label: "14\u201317", odds: 1.7, entry: 40, risk: 10 },
+            { label: "18+", odds: 2.9, entry: 25, risk: 35 },
+        ]},
+        { id: "rcb_top_wicket", question: "Highest wicket-taker \u2014 Bengaluru?", icon: "target", accent: "#22E3E8", category: "rcb_innings", options: [
+            { label: "Hazlewood", odds: 3.3, entry: 30, risk: 38 },
+            { label: "Noor", odds: 4.0, entry: 25, risk: 48 },
+            { label: "Bhuvneshwar", odds: 4.5, entry: 25, risk: 55 },
+            { label: "Others", odds: 6.0, entry: 20, risk: 65 },
+        ]},
+        { id: "combined_score", question: "Combined match score?", icon: "chart", accent: "#9945FF", category: "match_level", options: [
+            { label: "<300", odds: 3.2, entry: 25, risk: 38 },
+            { label: "300\u2013350", odds: 2.3, entry: 35, risk: 22 },
+            { label: "351\u2013400", odds: 1.7, entry: 45, risk: 10 },
+            { label: "401+", odds: 3.6, entry: 25, risk: 42 },
+        ]},
+        { id: "total_fours_match", question: "Total 4s in match?", icon: "four", accent: "#f83cc5", category: "match_level", options: [
+            { label: "<20", odds: 2.8, entry: 30, risk: 32 },
+            { label: "20\u201330", odds: 1.9, entry: 40, risk: 15 },
+            { label: "31\u201340", odds: 1.6, entry: 45, risk: 8 },
+            { label: "41+", odds: 2.7, entry: 30, risk: 30 },
+        ]},
+        { id: "total_sixes_match", question: "Total 6s in match?", icon: "six", accent: "#22E3E8", category: "match_level", options: [
+            { label: "<18", odds: 2.5, entry: 30, risk: 28 },
+            { label: "18\u201325", odds: 1.8, entry: 40, risk: 12 },
+            { label: "26\u201335", odds: 1.7, entry: 40, risk: 10 },
+            { label: "36+", odds: 3.0, entry: 25, risk: 35 },
+        ]},
+        { id: "potm", question: "Player of the Match?", icon: "star", accent: "#9945FF", category: "match_level", options: [
+            { label: "V Kohli", odds: 4.0, entry: 30, risk: 48 },
+            { label: "R Gaikwad", odds: 4.5, entry: 25, risk: 55 },
+            { label: "S Samson", odds: 5.0, entry: 25, risk: 60 },
+            { label: "C Overton", odds: 6.0, entry: 20, risk: 65 },
+        ]},
+    ],
+};
+
+// ────── Pool generation (seedrandom) ──────
+
+const SCORE_QUANTILES: [number, number, number][] = [
+    [0.300,   700,     999],
+    [0.800,   1000,    1574],
+    [0.875,   1575,    2282],
+    [0.930,   2283,    3625],
+    [0.965,   3626,    6134],
+    [0.9825,  6135,    10995],
+    [0.9915,  10996,   20041],
+    [0.9965,  20042,   34434],
+    [0.99875, 34435,   62529],
+    [0.99960, 62530,   106664],
+    [0.99980, 106665,  183994],
+    [0.99990, 183995,  315004],
+    [1.0,     315005,  559884],
+];
+
+function generateScore(rng: () => number): number {
+    const u = rng();
+    for (const [cumProb, min, max] of SCORE_QUANTILES) {
+        if (u < cumProb) return Math.round(min + rng() * (max - min));
+    }
+    return SCORE_QUANTILES[SCORE_QUANTILES.length - 1][2];
+}
+
+export function generatePool(config: IChallengeConfig): IPoolData {
+    const rng = seedrandom(config.leaderboardSeed);
+    const scores: number[] = [];
+    for (let i = 0; i < config.totalEntries - 1; i++) {
+        scores.push(generateScore(rng));
+    }
+    scores.sort((a, b) => b - a);
+    return { scores, seed: config.leaderboardSeed };
+}
+
+function walletForIndex(seed: string, index: number): string {
+    const rng = seedrandom(`${seed}-w-${index}`);
+    const chars = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnopqrstuvwxyz123456789";
+    const pick = () => chars[Math.floor(rng() * chars.length)];
+    return `${pick()}${pick()}${pick()}${pick()}..${pick()}${pick()}${pick()}${pick()}`;
+}
+
+export const CSK_VS_RCB_POOL = generatePool(CSK_VS_RCB_CHALLENGE);
+
+// ────── Calculations ──────
+
+export function optionReward(opt: IChallengeOption): number {
+    return Math.round(opt.entry * opt.odds);
+}
+
+export function calcBetSummary(
+    bets: IUserBets,
+    config: IChallengeConfig,
+): IBetSummary {
+    const { markets, startingBalance } = config;
+    const selectedCount = Object.keys(bets).length;
+    const compoundMultiplier = config.compoundMultipliers[selectedCount] ?? 1;
+
+    const parlayGroups = deriveParlayGroups(bets);
+
+    const activeSlots = new Set<number>();
+    for (const [slot, legs] of Object.entries(parlayGroups)) {
+        if (legs.length >= 2) activeSlots.add(Number(slot));
+    }
+
+    let totalEntry = 0;
+    let baseReward = 0;
+    let weightedRiskSum = 0;
+
+    for (const [mIdxStr, { optionIdx, amount, parlaySlot }] of Object.entries(bets)) {
+        const mIdx = Number(mIdxStr);
+        const opt = markets[mIdx].options[optionIdx];
+        totalEntry += amount;
+        weightedRiskSum += amount * opt.risk;
+
+        const isInActiveParlay = parlaySlot !== null && activeSlots.has(parlaySlot);
+        if (!isInActiveParlay) {
+            baseReward += Math.round(amount * opt.odds);
+        }
+    }
+
+    for (const slot of activeSlots) {
+        const legs = parlayGroups[slot];
+        let combinedOdds = 1;
+        let parlayStake = 0;
+        for (const mIdx of legs) {
+            const bet = bets[mIdx];
+            const opt = markets[mIdx].options[bet.optionIdx];
+            combinedOdds *= opt.odds;
+            parlayStake += bet.amount;
+        }
+        baseReward += Math.round(parlayStake * combinedOdds);
+    }
+
+    const compoundedReward = Math.round(baseReward * compoundMultiplier);
+    const remainingBalance = startingBalance - totalEntry;
+    const potentialBalance = remainingBalance + compoundedReward;
+    const riskPercent = totalEntry > 0
+        ? Math.min(Math.round(weightedRiskSum / totalEntry), 100)
+        : 0;
+
+    return {
+        selectedCount,
+        compoundMultiplier,
+        totalEntry,
+        baseReward,
+        compoundedReward,
+        remainingBalance,
+        potentialBalance,
+        riskPercent,
+    };
+}
+
+export function calcParlayMultiplier(
+    slot: number,
+    bets: IUserBets,
+    config: IChallengeConfig,
+): { multiplier: number; totalStake: number; breakdown: { question: string; odds: number }[] } {
+    const breakdown: { question: string; odds: number }[] = [];
+    let multiplier = 1;
+    let totalStake = 0;
+    for (const [mIdxStr, entry] of Object.entries(bets)) {
+        if (entry.parlaySlot !== slot) continue;
+        const mIdx = Number(mIdxStr);
+        const market = config.markets[mIdx];
+        const opt = market.options[entry.optionIdx];
+        multiplier *= opt.odds;
+        totalStake += entry.amount;
+        breakdown.push({ question: market.question, odds: opt.odds });
+    }
+    return { multiplier: Math.round(multiplier * 100) / 100, totalStake, breakdown };
+}
+
+export function calcPrizePool(config: IChallengeConfig): number {
+    return config.entryFee * config.totalEntries * (1 - config.rakePercent);
+}
+
+export function calcRankPayout(rank: number, config: IChallengeConfig): number {
+    const bracket = config.rankBrackets.find(b => rank >= b.from && rank <= b.to);
+    if (!bracket) return 0;
+    const pool = calcPrizePool(config);
+    const ranksInBracket = bracket.to - bracket.from + 1;
+    const perRank = (bracket.poolPercent / ranksInBracket) * pool;
+    return Math.round(perRank * 10) / 10;
+}
+
+// ────── Rank finding (binary search) ──────
+
+function findUserRank(pool: IPoolData, userPts: number): number {
+    const scores = pool.scores;
+    let lo = 0, hi = scores.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (scores[mid] > userPts) lo = mid + 1;
+        else hi = mid;
+    }
+    return lo + 1;
+}
+
+function poolEntryAtRank(
+    pool: IPoolData,
+    rank: number,
+    userRank: number,
+    config: IChallengeConfig,
+): ILeaderboardEntry {
+    const idx = rank < userRank ? rank - 1 : rank - 2;
+    return {
+        wallet: walletForIndex(pool.seed, idx),
+        pts: pool.scores[idx],
+        payout: calcRankPayout(rank, config),
+        isYou: false,
+        rank,
+    };
+}
+
+// ────── Visible leaderboard builder ──────
+
+export function buildPoolLeaderboard(
+    pool: IPoolData,
+    userPts: number,
+    config: IChallengeConfig,
+): { rows: ILeaderboardEntry[]; mini: IMiniLeaderboard } {
+    const totalPlayers = config.totalEntries;
+    const userRank = findUserRank(pool, userPts);
+
+    const rankSet = new Set<number>();
+    for (let r = 1; r <= Math.min(3, totalPlayers); r++) rankSet.add(r);
+    for (let r = Math.max(1, userRank - 3); r <= Math.min(totalPlayers, userRank + 3); r++) {
+        rankSet.add(r);
+    }
+    const visibleRanks = [...rankSet].sort((a, b) => a - b);
+
+    const rows: ILeaderboardEntry[] = [];
+    for (let i = 0; i < visibleRanks.length; i++) {
+        const rank = visibleRanks[i];
+        const gapAbove = i > 0 && visibleRanks[i - 1] < rank - 1;
+
+        if (rank === userRank) {
+            rows.push({
+                wallet: "You",
+                pts: userPts,
+                payout: calcRankPayout(rank, config),
+                isYou: true,
+                rank,
+                gapAbove,
+            });
+        } else {
+            const entry = poolEntryAtRank(pool, rank, userRank, config);
+            entry.gapAbove = gapAbove;
+            rows.push(entry);
+        }
+    }
+
+    const youEntry = rows.find(e => e.isYou)!;
+    const above = userRank > 1
+        ? poolEntryAtRank(pool, userRank - 1, userRank, config)
+        : null;
+    const below = userRank < totalPlayers
+        ? poolEntryAtRank(pool, userRank + 1, userRank, config)
+        : null;
+
+    const mini: IMiniLeaderboard = {
+        rank: userRank,
+        you: youEntry,
+        above,
+        below,
+        aboveRank: userRank - 1,
+        belowRank: userRank + 1,
+        total: totalPlayers,
+    };
+
+    return { rows, mini };
+}
+
+export function calcDisplayReward(
+    opt: IChallengeOption,
+    compoundMultiplier: number,
+    isSelected: boolean,
+    selectedCount: number,
+    betAmount?: number,
+): number {
+    const base = betAmount != null ? Math.round(betAmount * opt.odds) : optionReward(opt);
+    if (isSelected && selectedCount >= 2) {
+        return Math.round(base * compoundMultiplier);
+    }
+    return base;
+}

package/src/games/prematch-bets/constants.tsx

@@ -0,0 +1,33 @@
+// @devrongx/games — games/prematch-bets/constants.tsx
+// Shared constants and micro-components for IPL betting UI.
+
+import Image from "next/image";
+import { Coins, Trophy, Swords, Square, Zap, Target, BarChart3, Star } from "lucide-react";
+
+/** Font style applied to all betting UI text */
+export const OUTFIT = { fontFamily: "Outfit, sans-serif" } as const;
+
+/** Icon map keyed by config string — shared across market renderers */
+export const MARKET_ICONS: Record<string, typeof Coins> = {
+    coin: Coins,
+    trophy: Trophy,
+    bat: Swords,
+    four: Square,
+    six: Zap,
+    target: Target,
+    chart: BarChart3,
+    star: Star,
+};
+
+/** Points logo at a given size */
+export const PointsIcon = ({ size = 7, className = "" }: { size?: number; className?: string }) => (
+    <Image src="/iamgame_square_logo.jpg" alt="" width={size} height={size} className={`rounded-[${Math.max(1, Math.round(size / 5))}px] ${className}`} />
+);
+
+/** Purple checkmark inside white circle — used for selected options */
+export const SelectedCheck = ({ size = 10 }: { size?: number }) => (
+    <svg width={size} height={size} viewBox="0 0 16 16" fill="none">
+        <circle cx="8" cy="8" r="8" fill="white" />
+        <path d="M5 8l2 2 4-4" stroke="#9945FF" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" />
+    </svg>
+);

package/src/games/prematch-bets/index.ts

@@ -0,0 +1,4 @@
+// @devrongx/games — games/prematch-bets barrel
+export { PreMatchBetsPopup } from "./PreMatchBetsPopup";
+export { CSK_VS_RCB_CHALLENGE, CSK_VS_RCB_POOL, calcBetSummary, buildPoolLeaderboard, generatePool, calcPrizePool, calcRankPayout, calcParlayMultiplier, calcDisplayReward, optionReward, deriveParlayGroups, deriveMarketToParlay, extractUserBets } from "./config";
+export type { IChallengeConfig, IChallengeMarket, IChallengeOption, IChallengeTeam, IChallengeGame, IChallengeSection, IRankBracket, IParlayConfig, IUserBets, IBetEntry, IBetSummary, ILeaderboardEntry, IMiniLeaderboard, IPoolData, ISelectedBets, IParlayState } from "./config";

package/src/index.ts

@@ -0,0 +1,10 @@
+// @devrongx/games — top-level barrel
+// Core infrastructure
+export { GamePopupShell } from "./core/GamePopupShell";
+export { useGamePopupStore } from "./core/gamePopupStore";
+export type { IGamePopupState } from "./core/types";
+
+// Games — Pre-Match Bets
+export { PreMatchBetsPopup } from "./games/prematch-bets/PreMatchBetsPopup";
+export { CSK_VS_RCB_CHALLENGE, CSK_VS_RCB_POOL, calcBetSummary, buildPoolLeaderboard, generatePool, calcPrizePool, calcRankPayout, calcParlayMultiplier, calcDisplayReward, optionReward, deriveParlayGroups, deriveMarketToParlay, extractUserBets } from "./games/prematch-bets/config";
+export type { IChallengeConfig, IChallengeMarket, IChallengeOption, IChallengeTeam, IChallengeGame, IChallengeSection, IRankBracket, IParlayConfig, IUserBets, IBetEntry, IBetSummary, ILeaderboardEntry, IMiniLeaderboard, IPoolData } from "./games/prematch-bets/config";

package/src/styles/animations.css

@@ -0,0 +1,16 @@
+/* @devrongx/games — animations.css */
+/* Game-specific CSS keyframes and utility classes */
+
+@keyframes textFillSweep {
+  0%   { background-position: 100% 0; }
+  100% { background-position: 0% 0; }
+}
+
+@keyframes shine {
+  0% { background-position: -200% center; }
+  100% { background-position: 200% center; }
+}
+
+.animate-shine {
+  animation: shine 2s ease-in-out infinite;
+}