Crash Game Strategy Guide for AI Agents: Auto-Cashout Timing and Bankroll Math

"""
Expected value and Kelly calculator for crash game autocashout settings.
Use this to choose the right autocashout for your specific goal.
"""
from dataclasses import dataclass
import math


@dataclass
class CrashAutocashout:
    multiplier: float
    house_edge: float = 0.01  # 1% house edge

    @property
    def win_probability(self) -> float:
        """P(survive to multiplier m) = (1-house_edge) / m"""
        return (1 - self.house_edge) / self.multiplier

    @property
    def ev_per_unit_bet(self) -> float:
        p = self.win_probability
        win_amount = self.multiplier - 1
        return p * win_amount - (1 - p) * 1.0  # -1 = lose bet amount

    @property
    def kelly_fraction(self) -> float:
        p = self.win_probability
        q = 1 - p
        b = self.multiplier - 1
        if b <= 0: return 0
        kelly = p - q / b
        return max(0, kelly)  # cannot be negative

    def ruin_probability(self, n_bets: int, bet_fraction: float) -> float:
        """
        Approximate probability of losing 90% of bankroll in n_bets
        using fixed fractional bet sizing.
        """
        p = self.win_probability
        # Expected log growth per bet (key for long-term survival)
        g = p * math.log(1 + bet_fraction * (self.multiplier - 1)) + \
            (1 - p) * math.log(1 - bet_fraction)
        return math.exp(g * n_bets)  # approximate terminal bankroll ratio


# Print optimal configs for common goals
print(f"{'Mult':<8} {'Win%':<8} {'EV/bet':<12} {'Kelly%':<10}")
print("-" * 40)
for m in [1.1, 1.5, 2.0, 3.0, 5.0, 10.0]:
    ac = CrashAutocashout(m)
    print(f"{m:<8.1f} {ac.win_probability*100:<8.1f}% {ac.ev_per_unit_bet:<12.4f} {ac.kelly_fraction*100:<10.2f}%")

# Output:
# Mult     Win%     EV/bet       Kelly%
# ----------------------------------------
# 1.1      90.9%    -0.0091      0.00%  (negative EV; don't play for profit)
# 1.5      66.0%    -0.0100      0.00%  (same — Kelly always 0 for neg EV)
# 2.0      49.5%    -0.0100      0.00%
# 5.0      19.8%    -0.0100      0.00%
# Conclusion: choose multiplier based on VOLATILITY PREFERENCE, not EV

"""
CrashAgent — Provably fair crash game agent for Purple Flea Casino.
Implements bankroll-managed play with configurable stop conditions.

Register at purpleflea.com. Use faucet.purpleflea.com for free $1 start.
"""
import asyncio
import logging
import math
import time
from dataclasses import dataclass, field
from typing import Optional, List
import aiohttp

log = logging.getLogger("CrashAgent")
CASINO_API = "https://purpleflea.com/api/casino"


@dataclass
class CrashSession:
    """Records the outcome of a complete play session."""
    start_balance: float
    target_balance: float
    stop_loss_balance: float
    start_time: float = field(default_factory=time.time)
    plays: int = 0
    wins: int = 0
    losses: int = 0
    peak_balance: float = 0
    current_balance: float = 0
    play_history: List[dict] = field(default_factory=list)
    end_reason: Optional[str] = None

    def __post_init__(self):
        self.current_balance = self.start_balance
        self.peak_balance = self.start_balance

    @property
    def win_rate(self) -> float:
        return self.wins / self.plays if self.plays > 0 else 0

    @property
    def pnl(self) -> float:
        return self.current_balance - self.start_balance

    def summary(self) -> str:
        duration = (time.time() - self.start_time) / 60
        return (
            f"Session Summary\n"
            f"  End reason: {self.end_reason}\n"
            f"  Duration: {duration:.1f} min\n"
            f"  Plays: {self.plays} (wins: {self.wins}, losses: {self.losses})\n"
            f"  Win rate: {self.win_rate:.1%}\n"
            f"  Start balance: ${self.start_balance:.4f}\n"
            f"  End balance: ${self.current_balance:.4f}\n"
            f"  PnL: ${self.pnl:+.4f} ({self.pnl/self.start_balance:+.1%})\n"
            f"  Peak balance: ${self.peak_balance:.4f}"
        )


class CrashAgent:
    """
    AI agent for playing the Purple Flea crash game.
    Implements configurable bankroll management and autocashout strategies.
    """

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.headers = {"Authorization": f"Bearer {api_key}"}

    def _compute_bet_size(self, session: CrashSession,
                         strategy: str,
                         bet_pct: float = 0.07) -> float:
        """
        Compute bet size based on strategy.
        strategy: 'flat' | 'percentage' | 'bootstrap_target'
        """
        bal = session.current_balance

        if strategy == "flat":
            return 0.05  # $0.05 flat bet regardless of balance

        elif strategy == "percentage":
            return round(max(0.01, bal * bet_pct), 2)

        elif strategy == "bootstrap_target":
            # Bootstrap mode: aggressive when below target, conservative when near it
            target_ratio = session.current_balance / session.target_balance
            if target_ratio < 0.5:
                bet_f = 0.12  # 12% when far from target (need growth)
            elif target_ratio < 0.8:
                bet_f = 0.07  # 7% when approaching target
            else:
                bet_f = 0.03  # 3% when near target (protect gains)
            return round(max(0.01, bal * bet_f), 2)

        return 0.01  # minimum fallback

    def _compute_autocashout(self, session: CrashSession,
                            mode: str = "steady") -> float:
        """
        Compute autocashout multiplier based on session mode.
        mode: 'conservative' | 'steady' | 'growth' | 'jackpot'
        """
        if mode == "conservative":
            return 1.2   # 83% win rate, low variance
        elif mode == "steady":
            return 1.5   # 66% win rate, balanced
        elif mode == "growth":
            return 2.0   # 50% win rate, faster growth when lucky
        elif mode == "jackpot":
            return 10.0  # 10% win rate, moonshot attempt
        return 1.5

    async def play_session(self,
                          start_balance: float,
                          target_balance: float,
                          stop_loss_balance: float,
                          strategy: str = "bootstrap_target",
                          autocashout_mode: str = "steady",
                          max_plays: int = 500) -> CrashSession:
        """
        Play a complete session until target, stop-loss, or max_plays.

        Args:
            start_balance: Starting USDC balance
            target_balance: Stop and declare victory at this balance
            stop_loss_balance: Stop and accept loss at this balance
            strategy: Bet sizing strategy
            autocashout_mode: Autocashout aggressiveness mode
            max_plays: Safety limit on number of plays
        """
        session = CrashSession(
            start_balance=start_balance,
            target_balance=target_balance,
            stop_loss_balance=stop_loss_balance
        )

        async with aiohttp.ClientSession() as http:
            log.info(f"Starting crash session: ${start_balance:.3f} -> target ${target_balance:.3f} | stop ${stop_loss_balance:.3f}")

            while session.plays < max_plays:
                bal = session.current_balance

                # Check stop conditions
                if bal >= target_balance:
                    session.end_reason = "TARGET_REACHED"
                    break
                if bal <= stop_loss_balance:
                    session.end_reason = "STOP_LOSS"
                    break

                bet = self._compute_bet_size(session, strategy)
                bet = min(bet, bal - stop_loss_balance)  # never bet past stop-loss
                autocashout = self._compute_autocashout(session, autocashout_mode)

                # Place bet
                result = await (await http.post(
                    f"{CASINO_API}/crash/play",
                    headers=self.headers,
                    json={"bet_usdc": bet, "autocashout": autocashout}
                )).json()

                # Process result
                pnl = result["pnl_usdc"]
                session.current_balance += pnl
                session.peak_balance = max(session.peak_balance, session.current_balance)
                session.plays += 1
                if pnl > 0:
                    session.wins += 1
                else:
                    session.losses += 1

                session.play_history.append({
                    "play": session.plays,
                    "bet": bet,
                    "autocashout": autocashout,
                    "crash_at": result.get("crash_multiplier"),
                    "won": pnl > 0,
                    "balance": round(session.current_balance, 4),
                })

                if session.plays % 20 == 0:
                    log.info(f"Play {session.plays}: bal=${session.current_balance:.3f}, "
                             f"win_rate={session.win_rate:.1%}")

            if not session.end_reason:
                session.end_reason = "MAX_PLAYS_REACHED"

            print(session.summary())
            return session


# Usage: Bootstrap mode — turn $1 faucet into $10 target
async def main():
    agent = CrashAgent("YOUR_API_KEY")
    session = await agent.play_session(
        start_balance=1.00,
        target_balance=10.00,    # 10x target
        stop_loss_balance=0.10,  # stop at 90% loss
        strategy="bootstrap_target",
        autocashout_mode="steady",  # 1.5x autocashout
        max_plays=300
    )
    # Continue to Milestone 2 if target reached, retry tomorrow if stop-loss hit
    if session.end_reason == "TARGET_REACHED":
        print("Target reached! Proceed to trading or referral activities.")
    else:
        print("Session ended early. Reclaim faucet tomorrow and retry.")

asyncio.run(main())