《独立开发者的商业指南·合同、应收与风险》4.3 对方破产或失联：能拿回多少

可回收 = 11,264 × 10% = 1,126
缺口   = 11,264 − 1,126 = 10,138

// file: src/contract/bankruptcy.ts
// tier: L1
// verify: node --test test/contract/bankruptcy.test.ts

import { type Cents, add, sub } from "../core/money.ts";
import { type Bps, applyRate } from "../core/rate.ts";
import { type Result, fail, ok } from "../core/result.ts";

export type ClaimRank = 1 | 2 | 3;

export type BankruptcyClaim = {
  name: string;
  claimCents: Cents;
  rank: ClaimRank;
  recoveryBps: Bps;
};

export type ClaimPayout = {
  name: string;
  claimCents: Cents;
  capCents: Cents;
  paidCents: Cents;
  shortfallCents: Cents;
};

export type WaterfallResult = {
  estateCents: Cents;
  payouts: ClaimPayout[];
  totalPaidCents: Cents;
  totalShortfallCents: Cents;
  residualEstateCents: Cents;
};

function checkAmount(value: Cents, label: string): Result<true> {
  if (!Number.isInteger(value) || value < 0) {
    return fail(`${label} must be a non-negative integer amount in cents`);
  }
  return ok(true);
}

function checkRate(value: Bps, label: string): Result<true> {
  if (!Number.isInteger(value) || value < 0 || value > 10000) {
    return fail(`${label} must be between 0 and 10000 bps`);
  }
  return ok(true);
}

/**
 * Split an amount pro rata across caps. Floor each share, then hand the
 * remaining cents to the largest fractions, so the result always sums to the
 * amount without float drift.
 */
function allocateProRata(amount: Cents, caps: Cents[]): Cents[] {
  const totalCap = caps.reduce((acc, cap) => acc + cap, 0);
  if (amount === 0 || totalCap === 0) {
    return caps.map(() => 0);
  }
  if (amount >= totalCap) {
    return [...caps];
  }
  const exact = caps.map((cap) => (amount * cap) / totalCap);
  const shares = exact.map((value) => Math.floor(value));
  const assigned = shares.reduce((acc, value) => acc + value, 0);
  const order = exact
    .map((value, index) => ({ index, fraction: value - Math.floor(value) }))
    .sort((a, b) => b.fraction - a.fraction || a.index - b.index);
  for (let i = 0; i < amount - assigned; i += 1) {
    shares[order[i % order.length].index] += 1;
  }
  return shares;
}

/**
 * Distribute a bankruptcy estate by claim rank. Rank 1 is paid first, then
 * rank 2, then rank 3; each claim is capped by its teaching recovery rate.
 * Seniority matters more than the recovery rate: a fully secured claim can
 * consume the estate before a priority or unsecured claim sees anything.
 */
export function distributeEstate(
  estateCents: Cents,
  claims: BankruptcyClaim[],
): Result<WaterfallResult> {
  const estate = checkAmount(estateCents, "estate");
  if (!estate.ok) {
    return estate;
  }
  const caps: Cents[] = [];
  for (const claim of claims) {
    if (claim.name.trim() === "") {
      return fail("claim name cannot be empty");
    }
    const amount = checkAmount(claim.claimCents, `${claim.name} claim`);
    if (!amount.ok) {
      return amount;
    }
    if (claim.rank !== 1 && claim.rank !== 2 && claim.rank !== 3) {
      return fail(`${claim.name} rank must be 1, 2 or 3`);
    }
    const recovery = checkRate(claim.recoveryBps, `${claim.name} recovery rate`);
    if (!recovery.ok) {
      return recovery;
    }
    caps.push(applyRate(claim.claimCents, claim.recoveryBps));
  }

  let remaining = estateCents;
  const paid: Cents[] = claims.map(() => 0);
  for (const rank of [1, 2, 3] as ClaimRank[]) {
    const indices = claims
      .map((claim, index) => ({ claim, index }))
      .filter((entry) => entry.claim.rank === rank);
    if (indices.length === 0) {
      continue;
    }
    const groupCaps = indices.map((entry) => caps[entry.index]);
    const groupCap = groupCaps.reduce((acc, cap) => acc + cap, 0);
    const available = Math.min(remaining, groupCap);
    const shares = allocateProRata(available, groupCaps);
    indices.forEach((entry, offset) => {
      paid[entry.index] = shares[offset];
    });
    remaining = sub(remaining, available);
  }

  const payouts = claims.map((claim, index) => ({
    name: claim.name,
    claimCents: claim.claimCents,
    capCents: caps[index],
    paidCents: paid[index],
    shortfallCents: sub(claim.claimCents, paid[index]),
  }));
  const totalPaidCents = payouts.reduce((acc, payout) => add(acc, payout.paidCents), 0);
  const totalShortfallCents = payouts.reduce(
    (acc, payout) => add(acc, payout.shortfallCents),
    0,
  );
  return ok({
    estateCents,
    payouts,
    totalPaidCents,
    totalShortfallCents,
    residualEstateCents: remaining,
  });
}