《移动游戏产品的架构·商业化与发行工程》8.1 支付作弊与退款滥用

// file: src/biz/payment-fraud.ts
// tier: L1
// verify: node --test test/biz/payment-fraud.test.ts

export type FraudAction = "allow" | "review" | "freeze";
export type RiskLevel = "low" | "medium" | "high";

export interface PaymentOrder {
  readonly orderId: string;
  readonly amountCents: number;
  readonly paidAtMs: number;
  readonly productId: string;
}

export interface RefundRecord {
  readonly orderId: string;
  readonly amountCents: number;
  readonly refundedAtMs: number;
  readonly reason: "player-request" | "chargeback" | "channel-forced";
}

export interface AccountHistory {
  readonly accountId: string;
  readonly orders: readonly PaymentOrder[];
  readonly refunds: readonly RefundRecord[];
}

export interface FraudPolicy {
  readonly windowMs: number;
  readonly nowMs: number;
  readonly baselineRefundRate: number;
  readonly maxRefundRate: number;
  readonly maxRefundCount: number;
  readonly maxRefundAmountCents: number;
  readonly rapidWindowMs: number;
  readonly rapidOrderCount: number;
  readonly reviewScore: number;
  readonly freezeScore: number;
}

export interface Signal {
  readonly code: string;
  readonly points: number;
  readonly detail: string;
}

export interface FraudAssessment {
  readonly accountId: string;
  readonly orderCount: number;
  readonly refundCount: number;
  readonly refundRate: number;
  readonly refundedAmountCents: number;
  readonly score: number;
  readonly level: RiskLevel;
  readonly action: FraudAction;
  readonly signals: readonly Signal[];
}

export interface FraudExposure {
  readonly fraudOrders: number;
  readonly exposureCents: number;
}

export function estimateFraudExposure(
  ordersPerMonth: number,
  fraudRate: number,
  averageOrderCents: number,
): FraudExposure {
  const fraudOrders = Math.round(ordersPerMonth * fraudRate);
  return { fraudOrders, exposureCents: fraudOrders * averageOrderCents };
}

function inWindow(atMs: number, policy: FraudPolicy): boolean {
  return atMs <= policy.nowMs && policy.nowMs - atMs <= policy.windowMs;
}

function countRapidOrders(orders: readonly PaymentOrder[], policy: FraudPolicy): number {
  const recent = orders
    .filter((order) => inWindow(order.paidAtMs, policy))
    .map((order) => order.paidAtMs)
    .sort((left, right) => left - right);
  let best = 0;
  let start = 0;
  for (let end = 0; end < recent.length; end += 1) {
    while (recent[end]! - recent[start]! > policy.rapidWindowMs) {
      start += 1;
    }
    best = Math.max(best, end - start + 1);
  }
  return best;
}

export function assessRefundAbuse(
  history: AccountHistory,
  policy: FraudPolicy,
): FraudAssessment {
  const orders = history.orders.filter((order) => inWindow(order.paidAtMs, policy));
  const refunds = history.refunds.filter((refund) => inWindow(refund.refundedAtMs, policy));
  const refundedAmountCents = refunds.reduce((sum, refund) => sum + refund.amountCents, 0);
  const refundRate = orders.length === 0 ? 0 : refunds.length / orders.length;
  const signals: Signal[] = [];

  if (refunds.length >= policy.maxRefundCount) {
    signals.push({
      code: "refund-count",
      points: 25,
      detail: `${refunds.length} refunds in window, limit ${policy.maxRefundCount}`,
    });
  }
  if (refundRate > policy.maxRefundRate) {
    signals.push({
      code: "refund-rate",
      points: 25,
      detail: `refund rate ${(refundRate * 100).toFixed(2)}% exceeds ${(policy.maxRefundRate * 100).toFixed(2)}%`,
    });
  }
  if (orders.length >= 4 && refundRate > policy.baselineRefundRate * 2) {
    signals.push({
      code: "above-baseline",
      points: 10,
      detail: `refund rate ${(refundRate * 100).toFixed(2)}% is more than twice the baseline`,
    });
  }
  if (refundedAmountCents >= policy.maxRefundAmountCents) {
    signals.push({
      code: "refund-amount",
      points: 20,
      detail: `refunded ${refundedAmountCents} cents, limit ${policy.maxRefundAmountCents}`,
    });
  }
  const chargebacks = refunds.filter((refund) => refund.reason === "chargeback").length;
  if (chargebacks > 0) {
    signals.push({
      code: "chargeback",
      points: Math.min(30, chargebacks * 15),
      detail: `${chargebacks} chargeback(s) recorded`,
    });
  }
  const rapidOrders = countRapidOrders(orders, policy);
  if (rapidOrders >= policy.rapidOrderCount) {
    signals.push({
      code: "rapid-orders",
      points: 15,
      detail: `${rapidOrders} orders within ${policy.rapidWindowMs}ms`,
    });
  }
  const perOrder = new Map<string, number>();
  for (const refund of refunds) {
    perOrder.set(refund.orderId, (perOrder.get(refund.orderId) ?? 0) + 1);
  }
  const duplicated = [...perOrder.values()].filter((count) => count > 1).length;
  if (duplicated > 0) {
    signals.push({
      code: "duplicate-refund",
      points: 20,
      detail: `${duplicated} order(s) refunded more than once`,
    });
  }

  const score = Math.min(100, signals.reduce((sum, signal) => sum + signal.points, 0));
  const level: RiskLevel = score >= policy.freezeScore ? "high" : score >= policy.reviewScore ? "medium" : "low";
  const action: FraudAction = level === "high" ? "freeze" : level === "medium" ? "review" : "allow";
  return {
    accountId: history.accountId,
    orderCount: orders.length,
    refundCount: refunds.length,
    refundRate,
    refundedAmountCents,
    score,
    level,
    action,
    signals,
  };
}

export function formatFraudAssessment(assessment: FraudAssessment): string {
  const percent = (assessment.refundRate * 100).toFixed(2);
  const codes = assessment.signals.map((signal) => signal.code).join(",") || "none";
  return `${assessment.accountId} ${assessment.action} score=${assessment.score} refundRate=${percent}% signals=${codes}`;
}