@bash-app/bash-common 30.236.0 → 30.238.0

package/src/utils/__tests__/paymentUtils.test.ts

@@ -147,6 +147,99 @@ describe("PaymentUtils - Core Functions", () => {
       expect(r.applicationFeeAmountCents).toBe(r.stripeProcessingCents + 300);
     });
 
+    test("computeTicketApplicationFeeAmountCents — explicit isVerifiedNonprofitHost: false matches default", () => {
+      const baseArgs = {
+        discountedSubtotalCents: 10000,
+        platformFeeEnabled: true,
+        platformFeeRate: 0.03,
+        feeHandling: "HostAbsorbs" as const,
+        bashPassWaivesGuestFee: false,
+      };
+      const defaulted = computeTicketApplicationFeeAmountCents(baseArgs);
+      const explicitFalse = computeTicketApplicationFeeAmountCents({
+        ...baseArgs,
+        isVerifiedNonprofitHost: false,
+      });
+      expect(explicitFalse).toEqual(defaulted);
+    });
+
+    test("computeTicketApplicationFeeAmountCents — verified nonprofit host: zero Bash platform, Stripe untouched", () => {
+      const r = computeTicketApplicationFeeAmountCents({
+        discountedSubtotalCents: 10000,
+        platformFeeEnabled: true,
+        platformFeeRate: 0.03,
+        feeHandling: "GuestPays",
+        bashPassWaivesGuestFee: false,
+        isVerifiedNonprofitHost: true,
+      });
+      expect(r.bashPlatformTotalCents).toBe(0);
+      expect(r.guestPlatformLineCents).toBe(0);
+      expect(r.totalChargedCents).toBe(10000);
+      expect(r.stripeProcessingCents).toBe(calculateStripeProcessingFeeCents(10000));
+      expect(r.applicationFeeAmountCents).toBe(r.stripeProcessingCents);
+    });
+
+    test("computeTicketApplicationFeeAmountCents — verified nonprofit waiver overrides feeHandling=GuestPays", () => {
+      const nonNonprofit = computeTicketApplicationFeeAmountCents({
+        discountedSubtotalCents: 5000,
+        platformFeeEnabled: true,
+        platformFeeRate: 0.05,
+        feeHandling: "GuestPays",
+        bashPassWaivesGuestFee: false,
+      });
+      expect(nonNonprofit.bashPlatformTotalCents).toBe(250);
+      expect(nonNonprofit.guestPlatformLineCents).toBe(250);
+      expect(nonNonprofit.totalChargedCents).toBe(5250);
+
+      const nonprofit = computeTicketApplicationFeeAmountCents({
+        discountedSubtotalCents: 5000,
+        platformFeeEnabled: true,
+        platformFeeRate: 0.05,
+        feeHandling: "GuestPays",
+        bashPassWaivesGuestFee: false,
+        isVerifiedNonprofitHost: true,
+      });
+      expect(nonprofit.bashPlatformTotalCents).toBe(0);
+      expect(nonprofit.guestPlatformLineCents).toBe(0);
+      expect(nonprofit.totalChargedCents).toBe(5000);
+      expect(nonprofit.applicationFeeAmountCents).toBe(nonprofit.stripeProcessingCents);
+    });
+
+    test("computeTicketApplicationFeeAmountCents — verified nonprofit waiver beats any membership-tier math", () => {
+      const tierCases = [
+        { feeHandling: "HostAbsorbs" as const, bashPassWaivesGuestFee: false },
+        { feeHandling: "Split" as const, bashPassWaivesGuestFee: false },
+        { feeHandling: "GuestPays" as const, bashPassWaivesGuestFee: true },
+      ];
+      for (const tier of tierCases) {
+        const r = computeTicketApplicationFeeAmountCents({
+          discountedSubtotalCents: 12345,
+          platformFeeEnabled: true,
+          platformFeeRate: 0.04,
+          feeHandling: tier.feeHandling,
+          bashPassWaivesGuestFee: tier.bashPassWaivesGuestFee,
+          isVerifiedNonprofitHost: true,
+        });
+        expect(r.bashPlatformTotalCents).toBe(0);
+        expect(r.guestPlatformLineCents).toBe(0);
+        expect(r.totalChargedCents).toBe(12345);
+        expect(r.applicationFeeAmountCents).toBe(r.stripeProcessingCents);
+      }
+    });
+
+    test("computeTicketApplicationFeeAmountCents — verified nonprofit + platformFeeEnabled=false still zeroes the take", () => {
+      const r = computeTicketApplicationFeeAmountCents({
+        discountedSubtotalCents: 2500,
+        platformFeeEnabled: false,
+        platformFeeRate: 0.03,
+        feeHandling: "HostAbsorbs",
+        bashPassWaivesGuestFee: false,
+        isVerifiedNonprofitHost: true,
+      });
+      expect(r.bashPlatformTotalCents).toBe(0);
+      expect(r.applicationFeeAmountCents).toBe(r.stripeProcessingCents);
+    });
+
     test("userHasActiveBashPass", () => {
       expect(userHasActiveBashPass({ bashPassStripeSubscriptionId: null, bashPassCurrentPeriodEnd: null })).toBe(false);
       expect(userHasActiveBashPass({ bashPassStripeSubscriptionId: "sub_1", bashPassCurrentPeriodEnd: null })).toBe(true);

package/src/utils/nonprofitUtils.ts

@@ -0,0 +1,44 @@
+import type { Organization } from "@prisma/client";
+
+/**
+ * Subset of `Organization` fields the verified-nonprofit helpers need. Callers
+ * may pass any prisma payload that selects (or includes) at least these
+ * columns — keeps consumers free to use narrow `select` shapes.
+ */
+export type NonprofitVerificationFields = Pick<
+  Organization,
+  | "nonprofitCountry"
+  | "nonprofitRegistrationNumber"
+  | "nonprofitVerifiedAt"
+  | "stripeNonprofitPricingStatus"
+>;
+
+/**
+ * Verified-nonprofit status is determined solely by an admin stamp:
+ * `nonprofitVerifiedAt` is set (in the past or now — future timestamps do
+ * NOT count) AND we captured `nonprofitCountry` + `nonprofitRegistrationNumber`.
+ * The Stripe nonprofit-pricing status is informational only and DOES NOT gate
+ * verification (a charity can be verified by Bash even before applying to
+ * Stripe).
+ *
+ * IMPORTANT: `BashEvent.nonProfit` is a user-entered flag and MUST NOT be
+ * passed in here. Fee-waiver code reads only the Organization's verification
+ * fields — see Phase 3 of the donation-followups-leak-fix plan.
+ */
+export function isVerifiedNonprofitOrganization(
+  org: NonprofitVerificationFields | null | undefined
+): boolean {
+  if (!org) return false;
+  if (!org.nonprofitVerifiedAt) return false;
+  if (org.nonprofitVerifiedAt.getTime() > Date.now()) return false;
+  if (!org.nonprofitCountry || org.nonprofitCountry.trim().length === 0) {
+    return false;
+  }
+  if (
+    !org.nonprofitRegistrationNumber ||
+    org.nonprofitRegistrationNumber.trim().length === 0
+  ) {
+    return false;
+  }
+  return true;
+}

package/src/utils/paymentUtils.ts

@@ -275,26 +275,52 @@ export function splitBashPlatformFeeForTicketCheckout(args: {
   return { totalPlatformCents: total, guestPlatformLineCents: guestLine };
 }
 
+/**
+ * Compute the Stripe Connect `application_fee_amount` for a ticket-style charge,
+ * along with its constituent parts.
+ *
+ * `isVerifiedNonprofitHost` waives ONLY Bash's platform take
+ * (`bashPlatformTotalCents`) — Stripe's pass-through (2.9% + $0.30) is untouched
+ * because that's not ours to waive. The host applies for Stripe nonprofit
+ * pricing directly. When `true`:
+ *   - `bashPlatformTotalCents` and `guestPlatformLineCents` are both zero
+ *   - `totalChargedCents` collapses to the discounted subtotal (no guest-line fee added)
+ *   - `applicationFeeAmountCents` equals `stripeProcessingCents`
+ *
+ * Default (`false`) preserves existing math bit-exact for every current caller.
+ */
 export function computeTicketApplicationFeeAmountCents(args: {
   discountedSubtotalCents: number;
   platformFeeEnabled: boolean;
   platformFeeRate: number;
   feeHandling: string | null | undefined;
   bashPassWaivesGuestFee: boolean;
+  /**
+   * Verified-nonprofit hosts pay no Bash platform fee. Sourced from
+   * `isVerifiedNonprofitOrganization()` over the host's Organization row —
+   * NEVER from `BashEvent.nonProfit`, which is user-entered.
+   */
+  isVerifiedNonprofitHost?: boolean;
 }): {
   totalChargedCents: number;
+  /** Stripe's 2.9% + $0.30 pass-through; unchanged by the nonprofit waiver. */
   stripeProcessingCents: number;
+  /** Bash's platform take. Zero when `isVerifiedNonprofitHost` is true. */
   bashPlatformTotalCents: number;
   applicationFeeAmountCents: number;
+  /** Guest-visible portion of the platform line. Zero when `isVerifiedNonprofitHost` is true. */
   guestPlatformLineCents: number;
 } {
-  const split = splitBashPlatformFeeForTicketCheckout({
-    grossCents: args.discountedSubtotalCents,
-    platformFeeEnabled: args.platformFeeEnabled,
-    platformFeeRate: args.platformFeeRate,
-    feeHandling: args.feeHandling,
-    bashPassWaivesGuestFee: args.bashPassWaivesGuestFee,
-  });
+  const isVerifiedNonprofitHost = args.isVerifiedNonprofitHost === true;
+  const split = isVerifiedNonprofitHost
+    ? { totalPlatformCents: 0, guestPlatformLineCents: 0 }
+    : splitBashPlatformFeeForTicketCheckout({
+        grossCents: args.discountedSubtotalCents,
+        platformFeeEnabled: args.platformFeeEnabled,
+        platformFeeRate: args.platformFeeRate,
+        feeHandling: args.feeHandling,
+        bashPassWaivesGuestFee: args.bashPassWaivesGuestFee,
+      });
   const guestPlatformLineCents = split.guestPlatformLineCents;
   const bashPlatformTotalCents = split.totalPlatformCents;
   const totalChargedCents = args.discountedSubtotalCents + guestPlatformLineCents;

package/src/utils/service/__tests__/billingCapUtils.test.ts

@@ -0,0 +1,175 @@
+import {
+  DEFAULT_MAX_BILLABLE_MULTIPLIER,
+  DEFAULT_MAX_BILLABLE_ROUNDING_CENTS,
+  DEFAULT_VARIABLE_PAYOUT_TIMING_NOTE,
+  defaultMaxBillableBashPoints,
+  defaultMaxBillableCents,
+  isFlatPricingModel,
+} from "../billingCapUtils";
+
+describe("defaultMaxBillableCents", () => {
+  it("computes 1.5x of expectedAttendees * baseRateCents, rounded up to $10", () => {
+    // 200 * $5 * 1.5 = $1500 — already a $10 multiple.
+    expect(
+      defaultMaxBillableCents({ expectedAttendees: 200, baseRateCents: 500 })
+    ).toBe(150_000);
+  });
+
+  it("rounds the cap UP to the nearest $10", () => {
+    // 217 * 500 * 1.5 = 162,750 cents = $1,627.50 → round up to $1,630.
+    expect(
+      defaultMaxBillableCents({ expectedAttendees: 217, baseRateCents: 500 })
+    ).toBe(163_000);
+  });
+
+  it("returns 0 when expectedAttendees is zero", () => {
+    expect(
+      defaultMaxBillableCents({ expectedAttendees: 0, baseRateCents: 500 })
+    ).toBe(0);
+  });
+
+  it("returns 0 when expectedAttendees is null or undefined", () => {
+    expect(
+      defaultMaxBillableCents({ expectedAttendees: null, baseRateCents: 500 })
+    ).toBe(0);
+    expect(
+      defaultMaxBillableCents({
+        expectedAttendees: undefined,
+        baseRateCents: 500,
+      })
+    ).toBe(0);
+  });
+
+  it("returns null when baseRateCents is missing or zero", () => {
+    expect(
+      defaultMaxBillableCents({ expectedAttendees: 100, baseRateCents: null })
+    ).toBeNull();
+    expect(
+      defaultMaxBillableCents({ expectedAttendees: 100, baseRateCents: 0 })
+    ).toBeNull();
+    expect(
+      defaultMaxBillableCents({
+        expectedAttendees: 100,
+        baseRateCents: undefined,
+      })
+    ).toBeNull();
+  });
+
+  it("clamps negative expectedAttendees to zero", () => {
+    expect(
+      defaultMaxBillableCents({ expectedAttendees: -50, baseRateCents: 500 })
+    ).toBe(0);
+  });
+
+  it("respects an explicit multiplier override", () => {
+    // 100 * 500 * 2.0 = 100,000 → $1,000.
+    expect(
+      defaultMaxBillableCents({
+        expectedAttendees: 100,
+        baseRateCents: 500,
+        multiplier: 2,
+      })
+    ).toBe(100_000);
+  });
+
+  it("falls back to default multiplier when override is invalid", () => {
+    const out = defaultMaxBillableCents({
+      expectedAttendees: 100,
+      baseRateCents: 500,
+      multiplier: 0,
+    });
+    expect(out).toBe(100 * 500 * DEFAULT_MAX_BILLABLE_MULTIPLIER);
+  });
+
+  it("respects a custom rounding granularity", () => {
+    // 200 * 500 * 1.5 = 150,000 cents = $1,500 — already a $100 multiple.
+    expect(
+      defaultMaxBillableCents({
+        expectedAttendees: 200,
+        baseRateCents: 500,
+        roundingCents: 10_000,
+      })
+    ).toBe(150_000);
+    // 101 * 500 * 1.5 = 75,750 cents = $757.50 → round up to nearest $100 = $800 = 80_000 cents.
+    expect(
+      defaultMaxBillableCents({
+        expectedAttendees: 101,
+        baseRateCents: 500,
+        roundingCents: 10_000,
+      })
+    ).toBe(80_000);
+  });
+
+  it("uses the platform default rounding when override is invalid", () => {
+    const out = defaultMaxBillableCents({
+      expectedAttendees: 217,
+      baseRateCents: 500,
+      roundingCents: 0,
+    });
+    // Falls back to DEFAULT rounding ($10) → same as the rounded case above.
+    expect(out).toBe(
+      Math.ceil((217 * 500 * 1.5) / DEFAULT_MAX_BILLABLE_ROUNDING_CENTS) *
+        DEFAULT_MAX_BILLABLE_ROUNDING_CENTS
+    );
+  });
+});
+
+describe("defaultMaxBillableBashPoints", () => {
+  it("computes the BP parallel of the USD cap, rounded up to nearest 100 BP", () => {
+    // 100 * 50 * 1.5 = 7,500 — already a 100-multiple.
+    expect(
+      defaultMaxBillableBashPoints({
+        expectedAttendees: 100,
+        baseRateBashPoints: 50,
+      })
+    ).toBe(7_500);
+  });
+
+  it("rounds up to the nearest 100 BashPoints", () => {
+    // 33 * 50 * 1.5 = 2,475 → round up to 2,500.
+    expect(
+      defaultMaxBillableBashPoints({
+        expectedAttendees: 33,
+        baseRateBashPoints: 50,
+      })
+    ).toBe(2_500);
+  });
+
+  it("returns null when baseRateBashPoints is missing", () => {
+    expect(
+      defaultMaxBillableBashPoints({
+        expectedAttendees: 100,
+        baseRateBashPoints: null,
+      })
+    ).toBeNull();
+  });
+});
+
+describe("isFlatPricingModel", () => {
+  it("recognizes the three flat models", () => {
+    expect(isFlatPricingModel("FLAT_FEE")).toBe(true);
+    expect(isFlatPricingModel("HOURLY")).toBe(true);
+    expect(isFlatPricingModel("PER_DAY")).toBe(true);
+  });
+
+  it("returns false for variable models", () => {
+    expect(isFlatPricingModel("PER_ATTENDEE")).toBe(false);
+    expect(isFlatPricingModel("PER_PAID_ATTENDEE")).toBe(false);
+    expect(isFlatPricingModel("PER_BASHPOINTS_ATTENDEE")).toBe(false);
+    expect(isFlatPricingModel("TICKET_REVENUE_PERCENTAGE")).toBe(false);
+    expect(isFlatPricingModel("TIERED")).toBe(false);
+    expect(isFlatPricingModel("CUSTOM")).toBe(false);
+  });
+
+  it("returns false for null / undefined / empty", () => {
+    expect(isFlatPricingModel(null)).toBe(false);
+    expect(isFlatPricingModel(undefined)).toBe(false);
+    expect(isFlatPricingModel("")).toBe(false);
+  });
+});
+
+describe("DEFAULT_VARIABLE_PAYOUT_TIMING_NOTE", () => {
+  it("mentions the ~3 business day window", () => {
+    expect(DEFAULT_VARIABLE_PAYOUT_TIMING_NOTE).toMatch(/3 business days/i);
+  });
+});

package/src/utils/service/__tests__/cancellationPolicyRefundResolver.test.ts

@@ -1,4 +1,4 @@
-import { ServiceCancellationPolicy } from "@prisma/client";
+import { ServiceCancellationPolicy } from "../../../mirroredPrismaEnums.js";
 import {
   hoursUntilEventStart,
   cancellationRuleThresholdHours,

package/src/utils/service/__tests__/eventPromoterPhase3.test.ts

@@ -0,0 +1,296 @@
+/**
+ * Phase 3 of the unified-pricing roadmap — tests for the
+ *   - counting basis chooser,
+ *   - locked-models set / validator update,
+ *   - mixed USD + BashPoints settlement math,
+ *   - BashPoints payout source resolver (pool-then-wallet).
+ *
+ * Lives next to `eventPromoterUtils.test.ts` so it picks up the same Jest
+ * config; pure-function-only, no Prisma.
+ */
+import { describe, expect, it } from "@jest/globals";
+import {
+  EVENT_PROMOTER_LOCKED_PRICING_MODELS,
+  computeEventPromoterMixedSettlement,
+  eventPromoterCountingBasisFor,
+  pickCheckedInForBasis,
+  resolveBashPointsPayoutSources,
+  validateEventPromoterPricing,
+} from "../eventPromoterUtils.js";
+
+describe("EVENT_PROMOTER_LOCKED_PRICING_MODELS", () => {
+  it("contains PER_ATTENDEE, PER_PAID_ATTENDEE, PER_BASHPOINTS_ATTENDEE in that order", () => {
+    expect([...EVENT_PROMOTER_LOCKED_PRICING_MODELS]).toEqual([
+      "PER_ATTENDEE",
+      "PER_PAID_ATTENDEE",
+      "PER_BASHPOINTS_ATTENDEE",
+    ]);
+  });
+});
+
+describe("validateEventPromoterPricing (Phase 3 model set)", () => {
+  it("accepts PER_ATTENDEE for Promoter subtype", () => {
+    expect(
+      validateEventPromoterPricing({
+        eventServiceSubType: "Promoter",
+        pricingModel: "PER_ATTENDEE",
+      }).ok
+    ).toBe(true);
+  });
+  it("accepts PER_PAID_ATTENDEE for Promoter subtype", () => {
+    expect(
+      validateEventPromoterPricing({
+        eventServiceSubType: "Promoter",
+        pricingModel: "PER_PAID_ATTENDEE",
+      }).ok
+    ).toBe(true);
+  });
+  it("accepts PER_BASHPOINTS_ATTENDEE for Promoter subtype", () => {
+    expect(
+      validateEventPromoterPricing({
+        eventServiceSubType: "Promoter",
+        pricingModel: "PER_BASHPOINTS_ATTENDEE",
+      }).ok
+    ).toBe(true);
+  });
+  it("rejects FLAT_FEE for Promoter subtype", () => {
+    const r = validateEventPromoterPricing({
+      eventServiceSubType: "Promoter",
+      pricingModel: "FLAT_FEE",
+    });
+    expect(r.ok).toBe(false);
+  });
+});
+
+describe("eventPromoterCountingBasisFor", () => {
+  it("PER_ATTENDEE → AllCheckedIn", () => {
+    expect(
+      eventPromoterCountingBasisFor({ pricingModel: "PER_ATTENDEE" })
+    ).toBe("AllCheckedIn");
+  });
+  it("PER_PAID_ATTENDEE without BP knob → PaidUsdOnly", () => {
+    expect(
+      eventPromoterCountingBasisFor({
+        pricingModel: "PER_PAID_ATTENDEE",
+        countsBashPointsTickets: false,
+      })
+    ).toBe("PaidUsdOnly");
+  });
+  it("PER_PAID_ATTENDEE with countsBashPointsTickets → PaidAny", () => {
+    expect(
+      eventPromoterCountingBasisFor({
+        pricingModel: "PER_PAID_ATTENDEE",
+        countsBashPointsTickets: true,
+      })
+    ).toBe("PaidAny");
+  });
+  it("PER_BASHPOINTS_ATTENDEE → PaidBpOnly regardless of knob", () => {
+    expect(
+      eventPromoterCountingBasisFor({
+        pricingModel: "PER_BASHPOINTS_ATTENDEE",
+        countsBashPointsTickets: true,
+      })
+    ).toBe("PaidBpOnly");
+  });
+  it("unknown / null pricing → AllCheckedIn (legacy fallback)", () => {
+    expect(eventPromoterCountingBasisFor({ pricingModel: null })).toBe(
+      "AllCheckedIn"
+    );
+  });
+});
+
+describe("pickCheckedInForBasis", () => {
+  const SNAPS = {
+    totalCheckedInAttendees: 220,
+    paidAttendeesAtSettle: 180,
+    paidInBashPointsAttendeesAtSettle: 30,
+  };
+  it("AllCheckedIn → total", () => {
+    expect(pickCheckedInForBasis("AllCheckedIn", SNAPS)).toBe(220);
+  });
+  it("PaidUsdOnly → paid USD", () => {
+    expect(pickCheckedInForBasis("PaidUsdOnly", SNAPS)).toBe(180);
+  });
+  it("PaidBpOnly → paid BP", () => {
+    expect(pickCheckedInForBasis("PaidBpOnly", SNAPS)).toBe(30);
+  });
+  it("PaidAny → USD + BP", () => {
+    expect(pickCheckedInForBasis("PaidAny", SNAPS)).toBe(210);
+  });
+  it("treats missing snapshots as zero", () => {
+    expect(
+      pickCheckedInForBasis("PaidUsdOnly", {
+        totalCheckedInAttendees: 100,
+      })
+    ).toBe(0);
+  });
+});
+
+describe("computeEventPromoterMixedSettlement", () => {
+  const baseSnaps = {
+    totalCheckedInAttendees: 250,
+    paidAttendeesAtSettle: 200,
+    paidInBashPointsAttendeesAtSettle: 50,
+  };
+
+  it("computes a positive USD delta when more USD attendees show up than expected", () => {
+    const r = computeEventPromoterMixedSettlement({
+      baseRateCents: 500,
+      expectedPaidAttendeesAtBooking: 150,
+      snapshots: baseSnaps,
+    });
+    expect(r.usdTotalCents).toBe(200 * 500);
+    expect(r.usdDeltaCents).toBe((200 - 150) * 500);
+    expect(r.cappedUsd).toBe(false);
+  });
+
+  it("respects the USD ceiling (maxUsdAttendeesAttributable)", () => {
+    const r = computeEventPromoterMixedSettlement({
+      baseRateCents: 500,
+      expectedPaidAttendeesAtBooking: 150,
+      maxUsdAttendeesAttributable: 175,
+      snapshots: baseSnaps,
+    });
+    expect(r.usdTotalCents).toBe(175 * 500);
+    expect(r.cappedUsd).toBe(false); // ceiling, not dollar cap
+  });
+
+  it("flags cappedUsd when maxBillableCents bites", () => {
+    const r = computeEventPromoterMixedSettlement({
+      baseRateCents: 500,
+      expectedPaidAttendeesAtBooking: 150,
+      maxBillableCents: 80_000, // < 200 * 500 = 100_000
+      snapshots: baseSnaps,
+    });
+    expect(r.usdTotalCents).toBe(80_000);
+    expect(r.cappedUsd).toBe(true);
+  });
+
+  it("computes the BP side independently from USD", () => {
+    const r = computeEventPromoterMixedSettlement({
+      baseRateBashPoints: 10,
+      expectedBpAttendeesAtBooking: 30,
+      snapshots: baseSnaps,
+    });
+    expect(r.usdTotalCents).toBe(0);
+    expect(r.bpTotal).toBe(50 * 10);
+    expect(r.bpDelta).toBe(20 * 10);
+  });
+
+  it("caps BP via maxBillableBashPoints", () => {
+    const r = computeEventPromoterMixedSettlement({
+      baseRateBashPoints: 10,
+      expectedBpAttendeesAtBooking: 30,
+      maxBillableBashPoints: 400,
+      snapshots: baseSnaps,
+    });
+    expect(r.bpTotal).toBe(400);
+    expect(r.cappedBp).toBe(true);
+  });
+
+  it("returns all zeros when neither side has a rate", () => {
+    const r = computeEventPromoterMixedSettlement({
+      snapshots: baseSnaps,
+    });
+    expect(r.usdTotalCents).toBe(0);
+    expect(r.usdDeltaCents).toBe(0);
+    expect(r.bpTotal).toBe(0);
+    expect(r.bpDelta).toBe(0);
+  });
+});
+
+describe("resolveBashPointsPayoutSources", () => {
+  it("HostWallet path drains wallet only", () => {
+    expect(
+      resolveBashPointsPayoutSources({
+        source: "HostWallet",
+        payoutBp: 100,
+        hostWalletBp: 500,
+        bashPoolBp: 9999, // ignored
+      })
+    ).toEqual({
+      fromPoolBp: 0,
+      fromWalletBp: 100,
+      shortfallBp: 0,
+      walletDebited: true,
+    });
+  });
+
+  it("HostWallet path with insufficient wallet returns shortfall", () => {
+    expect(
+      resolveBashPointsPayoutSources({
+        source: "HostWallet",
+        payoutBp: 100,
+        hostWalletBp: 60,
+      })
+    ).toEqual({
+      fromPoolBp: 0,
+      fromWalletBp: 60,
+      shortfallBp: 40,
+      walletDebited: true,
+    });
+  });
+
+  it("BashBpPool drains pool first, wallet covers the rest", () => {
+    expect(
+      resolveBashPointsPayoutSources({
+        source: "BashBpPool",
+        payoutBp: 100,
+        hostWalletBp: 500,
+        bashPoolBp: 70,
+      })
+    ).toEqual({
+      fromPoolBp: 70,
+      fromWalletBp: 30,
+      shortfallBp: 0,
+      walletDebited: true,
+    });
+  });
+
+  it("BashBpPool fully covered by pool leaves wallet untouched", () => {
+    expect(
+      resolveBashPointsPayoutSources({
+        source: "BashBpPool",
+        payoutBp: 50,
+        hostWalletBp: 500,
+        bashPoolBp: 100,
+      })
+    ).toEqual({
+      fromPoolBp: 50,
+      fromWalletBp: 0,
+      shortfallBp: 0,
+      walletDebited: false,
+    });
+  });
+
+  it("BashBpPool with empty pool falls through to wallet", () => {
+    expect(
+      resolveBashPointsPayoutSources({
+        source: "BashBpPool",
+        payoutBp: 100,
+        hostWalletBp: 50,
+        bashPoolBp: 0,
+      })
+    ).toEqual({
+      fromPoolBp: 0,
+      fromWalletBp: 50,
+      shortfallBp: 50,
+      walletDebited: true,
+    });
+  });
+
+  it("clamps negative inputs to zero", () => {
+    expect(
+      resolveBashPointsPayoutSources({
+        source: "HostWallet",
+        payoutBp: -10,
+        hostWalletBp: -5,
+      })
+    ).toEqual({
+      fromPoolBp: 0,
+      fromWalletBp: 0,
+      shortfallBp: 0,
+      walletDebited: false,
+    });
+  });
+});