fix(payments): group payouts-owed by currency instead of summing across them (#497) (#505)

transactions.currency is a real, populated currency_type enum column, but
computeOwedBalances() dropped it and summed raw amount across currencies —
a tenant with both USD and EUR PayPal sales got one meaningless combined
total. markPayoutPaid() then hardcoded currency: 'usd' on every inserted
payouts row regardless of what was actually collected.

TenantOwed.balances is now an array of per-currency CurrencyBalance entries
(grossCollected/grossOwed/alreadyPaid/netOwed/byProvider), never summed
together. The payouts page renders one table row per (tenant, currency)
pair and shows metric cards as one figure per currency (e.g. "$80.00 ·
€40.00"), and markPayoutPaid takes an explicit currency argument threaded
from the row being paid instead of assuming USD.

Live-verified locally: seeded a $100 USD PayPal sale and a €50 EUR Lemon
Squeezy sale for the same tenant, confirmed the payouts page showed two
separate rows with correct 80% splits, recorded a EUR payout, and confirmed
the inserted payouts row has currency='eur' (not 'usd') while the USD
row's owed amount was unaffected.

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>

Author: guillermoscript

app/[locale]/platform/payouts/page.tsx

@@ -7,8 +7,15 @@ import {
   IconWalletOff,
 } from '@tabler/icons-react'
 
-const usd = (n: number) =>
-  new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(n ?? 0)
+const money = (n: number, currency: string) =>
+  new Intl.NumberFormat('en-US', { style: 'currency', currency: currency.toUpperCase() }).format(n ?? 0)
+
+/** Renders one line per currency — amounts in different currencies are never summed into one number (#497). */
+function formatByCurrency(byCurrency: Record<string, number>) {
+  const entries = Object.entries(byCurrency).filter(([, amount]) => amount !== 0)
+  if (entries.length === 0) return money(0, 'usd')
+  return entries.map(([currency, amount]) => money(amount, currency)).join(' · ')
+}
 
 const PROVIDER_LABEL: Record<string, string> = {
   paypal: 'PayPal',
@@ -19,31 +26,67 @@ const PROVIDER_LABEL: Record<string, string> = {
 export default async function PlatformPayoutsPage() {
   const owed = await getPayoutsOwed()
 
-  const totalOwed = owed.reduce((sum, t) => sum + t.netOwed, 0)
-  const totalCollected = owed.reduce((sum, t) => sum + t.grossCollected, 0)
-  const totalPaidOut = owed.reduce((sum, t) => sum + t.alreadyPaid, 0)
-  const schoolsOwed = owed.filter((t) => t.netOwed > 0).length
+  // Per-currency totals across all tenants — kept separate, never summed together.
+  const totalOwedByCurrency: Record<string, number> = {}
+  const totalCollectedByCurrency: Record<string, number> = {}
+  const totalPaidOutByCurrency: Record<string, number> = {}
+  let schoolsOwed = 0
+
+  // One row per (tenant, currency) balance — a tenant with both USD and EUR
+  // sales gets two rows, not one summed row.
+  type Row = {
+    tenantId: string
+    tenantName: string
+    schoolPercentage: number
+    currency: string
+    grossCollected: number
+    alreadyPaid: number
+    netOwed: number
+    byProvider: Record<string, number>
+  }
+  const rows: Row[] = []
+
+  for (const tenant of owed) {
+    let tenantHasOwed = false
+    for (const balance of tenant.balances) {
+      totalOwedByCurrency[balance.currency] = (totalOwedByCurrency[balance.currency] ?? 0) + balance.netOwed
+      totalCollectedByCurrency[balance.currency] = (totalCollectedByCurrency[balance.currency] ?? 0) + balance.grossCollected
+      totalPaidOutByCurrency[balance.currency] = (totalPaidOutByCurrency[balance.currency] ?? 0) + balance.alreadyPaid
+      if (balance.netOwed > 0) tenantHasOwed = true
+      rows.push({
+        tenantId: tenant.tenantId,
+        tenantName: tenant.tenantName,
+        schoolPercentage: tenant.schoolPercentage,
+        currency: balance.currency,
+        grossCollected: balance.grossCollected,
+        alreadyPaid: balance.alreadyPaid,
+        netOwed: balance.netOwed,
+        byProvider: balance.byProvider,
+      })
+    }
+    if (tenantHasOwed) schoolsOwed++
+  }
 
   const metricCards = [
     {
       title: 'Currently Owed',
-      value: usd(totalOwed),
+      value: formatByCurrency(totalOwedByCurrency),
       sub: `${schoolsOwed} school${schoolsOwed === 1 ? '' : 's'} awaiting payout`,
       icon: IconWalletOff,
       bg: 'bg-amber-50 dark:bg-amber-950/40',
       iconColor: 'text-amber-600 dark:text-amber-400',
     },
     {
       title: 'Collected (single-account providers)',
-      value: usd(totalCollected),
+      value: formatByCurrency(totalCollectedByCurrency),
       sub: 'PayPal, Binance Pay, Lemon Squeezy — 100% lands in your account',
       icon: IconCoin,
       bg: 'bg-blue-50 dark:bg-blue-950/40',
       iconColor: 'text-blue-600 dark:text-blue-400',
     },
     {
       title: 'Paid Out (all time)',
-      value: usd(totalPaidOut),
+      value: formatByCurrency(totalPaidOutByCurrency),
       sub: 'Manually recorded payouts to schools',
       icon: IconReportMoney,
       bg: 'bg-emerald-50 dark:bg-emerald-950/40',
@@ -89,14 +132,15 @@ export default async function PlatformPayoutsPage() {
           <CardTitle>By school</CardTitle>
         </CardHeader>
         <CardContent>
-          {owed.length === 0 ? (
-            <p className="text-muted-foreground text-sm">No schools yet.</p>
+          {rows.length === 0 ? (
+            <p className="text-muted-foreground text-sm">No platform-settled sales yet.</p>
           ) : (
             <div className="overflow-x-auto">
               <table className="w-full text-sm">
                 <thead>
                   <tr className="border-b text-left text-[11px] uppercase tracking-wider text-muted-foreground">
                     <th className="pb-2 font-medium">School</th>
+                    <th className="pb-2 font-medium">Currency</th>
                     <th className="pb-2 font-medium">Providers</th>
                     <th className="pb-2 text-right font-medium">Collected</th>
                     <th className="pb-2 text-right font-medium">School %</th>
@@ -106,29 +150,31 @@ export default async function PlatformPayoutsPage() {
                   </tr>
                 </thead>
                 <tbody>
-                  {owed.map((t) => (
-                    <tr key={t.tenantId} className="border-b last:border-0">
-                      <td className="py-2.5 font-medium">{t.tenantName}</td>
+                  {rows.map((r) => (
+                    <tr key={`${r.tenantId}-${r.currency}`} className="border-b last:border-0">
+                      <td className="py-2.5 font-medium">{r.tenantName}</td>
+                      <td className="py-2.5 uppercase text-muted-foreground">{r.currency}</td>
                       <td className="py-2.5 text-muted-foreground">
-                        {Object.keys(t.byProvider).length === 0
+                        {Object.keys(r.byProvider).length === 0
                           ? '—'
-                          : Object.keys(t.byProvider).map((p) => PROVIDER_LABEL[p] ?? p).join(', ')}
+                          : Object.keys(r.byProvider).map((p) => PROVIDER_LABEL[p] ?? p).join(', ')}
                       </td>
-                      <td className="py-2.5 text-right tabular-nums">{usd(t.grossCollected)}</td>
+                      <td className="py-2.5 text-right tabular-nums">{money(r.grossCollected, r.currency)}</td>
                       <td className="py-2.5 text-right tabular-nums text-muted-foreground">
-                        {t.schoolPercentage}%
+                        {r.schoolPercentage}%
                       </td>
                       <td className="py-2.5 text-right tabular-nums text-muted-foreground">
-                        {usd(t.alreadyPaid)}
+                        {money(r.alreadyPaid, r.currency)}
                       </td>
                       <td className="py-2.5 text-right tabular-nums font-medium text-amber-600 dark:text-amber-400">
-                        {usd(t.netOwed)}
+                        {money(r.netOwed, r.currency)}
                       </td>
                       <td className="py-2.5 text-right">
                         <MarkPayoutPaidDialog
-                          tenantId={t.tenantId}
-                          tenantName={t.tenantName}
-                          netOwed={t.netOwed}
+                          tenantId={r.tenantId}
+                          tenantName={r.tenantName}
+                          netOwed={r.netOwed}
+                          currency={r.currency}
                         />
                       </td>
                     </tr>
@@ -144,7 +190,8 @@ export default async function PlatformPayoutsPage() {
         Stripe and Solana sales already split automatically and never appear here. Binance Pay
         (personal account) and manual/offline sales settle straight to the school and also never
         appear here — only PayPal, Binance Pay (merchant), and Lemon Squeezy do, since those settle
-        100% into your account today.
+        100% into your account today. Amounts in different currencies are shown and paid out
+        separately — they&apos;re never added together into one number.
       </p>
     </main>
   )

app/actions/platform/payouts.ts

@@ -29,10 +29,10 @@ export async function getPayoutsOwed(): Promise<TenantOwed[]> {
     admin.from('revenue_splits').select('tenant_id, school_percentage'),
     admin
       .from('transactions')
-      .select('tenant_id, payment_provider, amount, school_percentage_snapshot')
+      .select('tenant_id, payment_provider, amount, currency, school_percentage_snapshot')
       .eq('status', 'successful')
       .in('payment_provider', PLATFORM_SETTLED_PROVIDERS),
-    admin.from('payouts').select('tenant_id, amount').eq('payout_method', 'manual').eq('status', 'paid'),
+    admin.from('payouts').select('tenant_id, amount, currency').eq('payout_method', 'manual').eq('status', 'paid'),
   ])
 
   const schoolPercentageByTenant = new Map(
@@ -51,21 +51,22 @@ export async function getPayoutsOwed(): Promise<TenantOwed[]> {
         tenantId: t.tenant_id as string,
         paymentProvider: t.payment_provider as string,
         amount: t.amount as number,
+        currency: t.currency || 'usd',
         schoolPercentageSnapshot: t.school_percentage_snapshot as number | null,
       })),
-    (paid || []).map((p) => ({ tenantId: p.tenant_id, amount: p.amount }))
+    (paid || []).map((p) => ({ tenantId: p.tenant_id, amount: p.amount, currency: p.currency || 'usd' }))
   )
 }
 
-export async function markPayoutPaid(tenantId: string, amount: number, note?: string) {
+export async function markPayoutPaid(tenantId: string, amount: number, currency: string, note?: string) {
   const userId = await verifySuperAdmin()
   if (!(amount > 0)) throw new Error('Amount must be positive')
 
   const admin = createAdminClient()
   const { error } = await admin.from('payouts').insert({
     tenant_id: tenantId,
     amount,
-    currency: 'usd',
+    currency,
     status: 'paid',
     payout_method: 'manual',
     paid_at: new Date().toISOString(),

components/platform/mark-payout-paid-dialog.tsx

@@ -20,9 +20,10 @@ interface Props {
   tenantId: string
   tenantName: string
   netOwed: number
+  currency: string
 }
 
-export function MarkPayoutPaidDialog({ tenantId, tenantName, netOwed }: Props) {
+export function MarkPayoutPaidDialog({ tenantId, tenantName, netOwed, currency }: Props) {
   const router = useRouter()
   const [open, setOpen] = useState(false)
   const [amount, setAmount] = useState(netOwed.toFixed(2))
@@ -37,8 +38,8 @@ export function MarkPayoutPaidDialog({ tenantId, tenantName, netOwed }: Props) {
     }
     setLoading(true)
     try {
-      await markPayoutPaid(tenantId, parsed, note.trim() || undefined)
-      toast.success(`Recorded $${parsed.toFixed(2)} paid to ${tenantName}`)
+      await markPayoutPaid(tenantId, parsed, currency, note.trim() || undefined)
+      toast.success(`Recorded ${parsed.toFixed(2)} ${currency.toUpperCase()} paid to ${tenantName}`)
       setOpen(false)
       setNote('')
       router.refresh()
@@ -68,7 +69,7 @@ export function MarkPayoutPaidDialog({ tenantId, tenantName, netOwed }: Props) {
           </DialogHeader>
           <div className="space-y-3 py-2">
             <div className="space-y-1.5">
-              <Label htmlFor="payout-amount">Amount paid (USD)</Label>
+              <Label htmlFor="payout-amount">Amount paid ({currency.toUpperCase()})</Label>
               <Input
                 id="payout-amount"
                 type="number"

lib/payments/payouts-owed.ts

@@ -18,6 +18,11 @@
  * snapshot column (`schoolPercentageSnapshot: null`) fall back to the
  * tenant's current `schoolPercentage` — the same behavior this module had
  * before #496, so old data isn't retroactively wrong either way.
+ *
+ * Balances are grouped PER CURRENCY (issue #497) — a tenant with both USD and
+ * EUR sales owes two separate numbers, never one meaningless summed total.
+ * `transactions.currency` and `payouts.currency` are trusted as given; this
+ * module does no currency conversion, only grouping.
  */
 
 /** Used when a tenant has no `revenue_splits` row yet (shouldn't normally happen, but keeps callers from dividing by an absent value). */
@@ -33,73 +38,114 @@ export interface TenantOwedInput {
 export interface PlatformSettledTxn {
   tenantId: string
   paymentProvider: string
-  /** Successful transaction amount, major units. */
+  /** Successful transaction amount, major units, in `currency`. */
   amount: number
+  /** transactions.currency (e.g. 'usd', 'eur'). */
+  currency: string
   /** revenue_splits.school_percentage in effect when this transaction was created (0–100), or null for pre-#496 rows. */
   schoolPercentageSnapshot: number | null
 }
 
 export interface ManualPayoutRecord {
   tenantId: string
   amount: number
+  /** payouts.currency — the currency this payout was actually recorded in. */
+  currency: string
 }
 
-export interface TenantOwed {
-  tenantId: string
-  tenantName: string
-  schoolPercentage: number
-  /** Sum of platform-settled transaction amounts (100% of what was collected). */
+export interface CurrencyBalance {
+  currency: string
+  /** Sum of platform-settled transaction amounts in this currency (100% of what was collected). */
   grossCollected: number
-  /** Sum over transactions of amount × (that transaction's snapshotted split, or the tenant's current split if unsnapshotted) — the school's all-time share. */
+  /** Sum over this currency's transactions of amount × (that transaction's snapshotted split, or the tenant's current split if unsnapshotted). */
   grossOwed: number
-  /** Sum of manual payouts already recorded as paid for this tenant. */
+  /** Sum of manual payouts already recorded as paid in this currency. */
   alreadyPaid: number
-  /** max(grossOwed - alreadyPaid, 0) — what's currently owed. */
+  /** max(grossOwed - alreadyPaid, 0) — what's currently owed in this currency. */
   netOwed: number
-  /** Per-provider breakdown of grossCollected. */
+  /** Per-provider breakdown of grossCollected in this currency. */
   byProvider: Record<string, number>
 }
 
+export interface TenantOwed {
+  tenantId: string
+  tenantName: string
+  schoolPercentage: number
+  /** One entry per currency this tenant has platform-settled activity or payouts in. Never summed across currencies. */
+  balances: CurrencyBalance[]
+}
+
 export function computeOwedBalances(
   tenants: TenantOwedInput[],
   txns: PlatformSettledTxn[],
   paidPayouts: ManualPayoutRecord[],
 ): TenantOwed[] {
   const schoolPercentageByTenant = new Map(tenants.map((t) => [t.tenantId, t.schoolPercentage]))
 
-  const collectedByTenant = new Map<string, number>()
-  const owedByTenant = new Map<string, number>()
-  const byProviderByTenant = new Map<string, Record<string, number>>()
-  for (const txn of txns) {
-    collectedByTenant.set(txn.tenantId, (collectedByTenant.get(txn.tenantId) ?? 0) + txn.amount)
+  // tenantId -> currency -> partial balance
+  const byTenantCurrency = new Map<string, Map<string, { grossCollected: number; grossOwed: number; byProvider: Record<string, number> }>>()
 
-    const effectivePercentage = txn.schoolPercentageSnapshot ?? schoolPercentageByTenant.get(txn.tenantId) ?? 0
-    owedByTenant.set(txn.tenantId, (owedByTenant.get(txn.tenantId) ?? 0) + (txn.amount * effectivePercentage) / 100)
+  function bucket(tenantId: string, currency: string) {
+    let byCurrency = byTenantCurrency.get(tenantId)
+    if (!byCurrency) {
+      byCurrency = new Map()
+      byTenantCurrency.set(tenantId, byCurrency)
+    }
+    let entry = byCurrency.get(currency)
+    if (!entry) {
+      entry = { grossCollected: 0, grossOwed: 0, byProvider: {} }
+      byCurrency.set(currency, entry)
+    }
+    return entry
+  }
 
-    const byProvider = byProviderByTenant.get(txn.tenantId) ?? {}
-    byProvider[txn.paymentProvider] = (byProvider[txn.paymentProvider] ?? 0) + txn.amount
-    byProviderByTenant.set(txn.tenantId, byProvider)
+  for (const txn of txns) {
+    const entry = bucket(txn.tenantId, txn.currency)
+    entry.grossCollected += txn.amount
+    const effectivePercentage = txn.schoolPercentageSnapshot ?? schoolPercentageByTenant.get(txn.tenantId) ?? 0
+    entry.grossOwed += (txn.amount * effectivePercentage) / 100
+    entry.byProvider[txn.paymentProvider] = (entry.byProvider[txn.paymentProvider] ?? 0) + txn.amount
   }
 
-  const paidByTenant = new Map<string, number>()
+  const paidByTenantCurrency = new Map<string, Map<string, number>>()
   for (const payout of paidPayouts) {
-    paidByTenant.set(payout.tenantId, (paidByTenant.get(payout.tenantId) ?? 0) + payout.amount)
+    let byCurrency = paidByTenantCurrency.get(payout.tenantId)
+    if (!byCurrency) {
+      byCurrency = new Map()
+      paidByTenantCurrency.set(payout.tenantId, byCurrency)
+    }
+    byCurrency.set(payout.currency, (byCurrency.get(payout.currency) ?? 0) + payout.amount)
   }
 
   return tenants.map((tenant) => {
-    const grossCollected = collectedByTenant.get(tenant.tenantId) ?? 0
-    const grossOwed = owedByTenant.get(tenant.tenantId) ?? 0
-    const alreadyPaid = paidByTenant.get(tenant.tenantId) ?? 0
-    const netOwed = Math.max(grossOwed - alreadyPaid, 0)
+    const collected = byTenantCurrency.get(tenant.tenantId) ?? new Map()
+    const paid = paidByTenantCurrency.get(tenant.tenantId) ?? new Map()
+
+    // A currency can appear only in payouts (fully paid off, no outstanding
+    // transactions left in this grouping) — union both key sets so it's not dropped.
+    const currencies = new Set<string>([...collected.keys(), ...paid.keys()])
+
+    const balances: CurrencyBalance[] = Array.from(currencies).map((currency) => {
+      const entry = collected.get(currency)
+      const grossCollected = entry?.grossCollected ?? 0
+      const grossOwed = entry?.grossOwed ?? 0
+      const alreadyPaid = paid.get(currency) ?? 0
+      const netOwed = Math.max(grossOwed - alreadyPaid, 0)
+      return {
+        currency,
+        grossCollected,
+        grossOwed,
+        alreadyPaid,
+        netOwed,
+        byProvider: entry?.byProvider ?? {},
+      }
+    })
+
     return {
       tenantId: tenant.tenantId,
       tenantName: tenant.tenantName,
       schoolPercentage: tenant.schoolPercentage,
-      grossCollected,
-      grossOwed,
-      alreadyPaid,
-      netOwed,
-      byProvider: byProviderByTenant.get(tenant.tenantId) ?? {},
+      balances,
     }
   })
 }