The Backend of Luck

// VIP tier promotion engine with real-time event sourcing
object VipRuleProcessor {

  sealed trait VipTier
  case object Bronze   extends VipTier
  case object Silver   extends VipTier
  case object Gold     extends VipTier
  case object Platinum extends VipTier

  case class PlayerActivity(
    playerId:    UUID,
    totalWagered: BigDecimal,
    daysActive:   Int,
    deposits:     Int
  )

  def evaluateTier(activity: PlayerActivity): VipTier =
    activity match {
      case a if a.totalWagered > 500000 && a.daysActive > 180 => Platinum
      case a if a.totalWagered > 100000 && a.daysActive > 90  => Gold
      case a if a.totalWagered > 10000  && a.deposits > 5     => Silver
      case _                                                  => Bronze
    }
}

// Payment state machine with retry logic and PSP failover
sealed trait PaymentState
case object Initiated    extends PaymentState
case object Processing   extends PaymentState
case object Authorized   extends PaymentState
case object Captured     extends PaymentState
case object Failed       extends PaymentState
case object Refunded     extends PaymentState

case class Payment(
  id:       UUID,
  amount:   BigDecimal,
  currency: Currency,
  state:    PaymentState,
  pspChain: List[PSPConfig],   // failover chain
  attempts: Int = 0
)

def processPayment(payment: Payment): IO[Payment] =
  payment.pspChain match {
    case psp :: fallbacks =>
      psp.authorize(payment)
        .handleErrorWith { _ =>
          processPayment(payment.copy(
            pspChain = fallbacks,
            attempts = payment.attempts + 1
          ))
        }
    case Nil =>
      IO.pure(payment.copy(state = Failed))
  }

# Real-time fraud detection with velocity checks
from dataclasses import dataclass
from datetime import datetime, timedelta

@dataclass
class FraudSignal:
    player_id: str
    score: float
    rules_triggered: list[str]

class FraudDetector:
    def __init__(self, redis_client, threshold=0.75):
        self.redis = redis_client
        self.threshold = threshold

    async def evaluate(self, event: dict) -> FraudSignal:
        signals = []
        score = 0.0

        # Velocity check: deposits in last hour
        key = f"deposits:{event['player_id']}:1h"
        count = await self.redis.incr(key)
        if count > 5:
            score += 0.4
            signals.append("high_deposit_velocity")

        # Device fingerprint mismatch
        known = await self.redis.smembers(
            f"devices:{event['player_id']}"
        )
        if event["device_fp"] not in known:
            score += 0.3
            signals.append("new_device")

        return FraudSignal(
            player_id=event["player_id"],
            score=min(score, 1.0),
            rules_triggered=signals
        )