How Purple Flea's Provably Fair
Casino Works: A Technical Deep Dive

hmac_bytes = HMAC-SHA256(key=server_seed, msg=f"{client_seed}:{nonce}")
result     = bytes_to_float(hmac_bytes)  # Float in [0, 1)
game_outcome = apply_game_rules(result)  # Map float to game result

import hmac, hashlib, struct


def verify_bet(
    server_seed: str,
    client_seed: str,
    nonce: int,
    expected_result: float,
    server_seed_hash: str,
) -> dict:
    """
    Verify a Purple Flea casino bet result.

    Args:
        server_seed:      The revealed server seed (hex string).
        client_seed:      Your client seed used for the bet.
        nonce:            The nonce (bet number for this seed pair).
        expected_result:  The float result [0,1) reported by the casino.
        server_seed_hash: The SHA-256 hash published before the bet.

    Returns:
        dict with keys: seed_hash_valid, result, result_matches, verified
    """
    # Step 1: Verify the server seed matches the pre-committed hash
    actual_hash = hashlib.sha256(server_seed.encode()).hexdigest()
    seed_hash_valid = (actual_hash == server_seed_hash)

    # Step 2: Compute the HMAC
    msg = f"{client_seed}:{nonce}".encode()
    key = server_seed.encode()
    hmac_bytes = hmac.new(key, msg, hashlib.sha256).digest()

    # Step 3: Convert first 4 bytes to a float in [0, 1)
    # Interpret as big-endian uint32, divide by 2^32
    uint32_val = struct.unpack(">I", hmac_bytes[:4])[0]
    computed_result = uint32_val / ((2 ** 32))

    result_matches = abs(computed_result - expected_result) < 1e-9

    return {
        "seed_hash_valid": seed_hash_valid,
        "result":          computed_result,
        "result_matches":  result_matches,
        "verified":        seed_hash_valid and result_matches,
        "hmac_hex":        hmac_bytes.hex(),
    }


# Example: verify a dice bet
result = verify_bet(
    server_seed      = "a4f2c8e1b3d7f9a2e5c8d1b4f7a3e6c9",
    client_seed      = "my-agent-seed-2026",
    nonce            = 42,
    expected_result  = 0.7341,  # Reported by casino (73.41)
    server_seed_hash = "3e7a2f...",  # Hash published before bet
)

print(f"Seed hash valid:  {result['seed_hash_valid']}")
print(f"Computed result:  {result['result']:.6f}")
print(f"Result matches:   {result['result_matches']}")
print(f"Fully verified:   {result['verified']}")

def dice_result(raw: float, house_edge: float = 0.01) -> float:
    """
    Maps [0,1) float to dice roll [0, 100) with 1% house edge applied.
    Roll range is [0, 99) — the top 1% is the house's cut.
    """
    return raw * 100 * (1 - house_edge)


def crash_multiplier(raw: float, house_edge: float = 0.01) -> float:
    """
    Maps [0,1) float to crash game multiplier.
    Uses the standard crash formula: 1 / (1 - raw) * (1 - house_edge)
    Clamped to minimum 1.0x.
    """
    if raw == 0:
        return 1.0
    raw_mult = 1 / (1 - raw)
    return max(1.0, raw_mult * (1 - house_edge))


def coin_flip(raw: float) -> str:
    """Maps [0,1) to heads or tails. <0.5 = heads, >=0.5 = tails."""
    return "heads" if raw < 0.5 else "tails"


def blackjack_card(raw: float) -> tuple[str, int]:
    """Maps [0,1) to a playing card. 52 cards mapped evenly."""
    suits = ["♠", "♥", "♦", "♣"]
    ranks = ["2","3","4","5","6","7","8","9","10","J","Q","K","A"]
    values = [2,3,4,5,6,7,8,9,10,10,10,10,11]
    card_idx  = int(raw * 52)
    suit_idx  = card_idx // 13
    rank_idx  = card_idx % 13
    return f"{ranks[rank_idx]}{suits[suit_idx]}", values[rank_idx]


# Demonstrate all three games from same HMAC result
raw = 0.7341
print(f"Raw result:         {raw}")
print(f"Dice roll:          {dice_result(raw):.2f}")
print(f"Crash multiplier:   {crash_multiplier(raw):.2f}x")
print(f"Coin flip:          {coin_flip(raw)}")
card, value = blackjack_card(raw)
print(f"Blackjack card:     {card} (value={value})")

import requests, hmac, hashlib, struct, os

CASINO_BASE = "https://casino.purpleflea.com"
API_KEY     = os.environ["PURPLE_FLEA_API_KEY"]
HEADERS     = {"Authorization": f"Bearer {API_KEY}"}


def get_bet_verification_data(bet_id: str) -> dict:
    """
    Fetch verification data for a completed bet.
    Returns server_seed (revealed), client_seed, nonce, server_seed_hash.
    """
    r = requests.get(
        f"{CASINO_BASE}/api/v1/bets/{bet_id}/verify",
        headers=HEADERS,
    )
    r.raise_for_status()
    return r.json()


def verify_from_api(bet_id: str) -> bool:
    data = get_bet_verification_data(bet_id)
    server_seed      = data["server_seed"]
    client_seed      = data["client_seed"]
    nonce            = data["nonce"]
    reported_result  = data["result"]
    server_seed_hash = data["server_seed_hash"]

    # Verify hash
    actual_hash = hashlib.sha256(server_seed.encode()).hexdigest()
    assert actual_hash == server_seed_hash, "Server seed hash mismatch!"

    # Compute HMAC
    msg = f"{client_seed}:{nonce}".encode()
    hmac_bytes = hmac.new(server_seed.encode(), msg, hashlib.sha256).digest()
    uint32_val = struct.unpack(">I", hmac_bytes[:4])[0]
    computed   = uint32_val / (2 ** 32)

    match = abs(computed - reported_result) < 1e-9
    print(f"Bet {bet_id}: result={reported_result:.6f}  computed={computed:.6f}  match={match}")
    return match


# Verify last 10 bets
recent = requests.get(f"{CASINO_BASE}/api/v1/bets?limit=10", headers=HEADERS)
for bet in recent.json()["bets"]:
    verify_from_api(bet["id"])