@agoric/inter-protocol 0.17.0 → 0.17.1-upgrade-23-dev-bd79330.0.bd79330

package/src/vaultFactory/liquidation.js

@@ -1,309 +0,0 @@
-// @jessie-check
-
-import { AmountMath } from '@agoric/ertp';
-import { makeTracer } from '@agoric/internal';
-import { observeIteration, subscribeEach } from '@agoric/notifier';
-import { makeScalarMapStore } from '@agoric/store';
-import { TimeMath } from '@agoric/time';
-import { E } from '@endo/eventual-send';
-
-import { AUCTION_START_DELAY, PRICE_LOCK_PERIOD } from '../auction/params.js';
-import { makeCancelTokenMaker } from '../auction/util.js';
-
-const trace = makeTracer('LIQ');
-
-/**
- * @import {MapStore, SetStore} from '@agoric/store';
- * @import {RelativeTimeRecord, TimerService, TimerWaker} from '@agoric/time';
- * @import {PriceQuote} from '@agoric/zoe/tools/types.js';
- */
-
-const makeCancelToken = makeCancelTokenMaker('liq');
-
-/**
- * This will normally be set. If the schedule goes sideways, we'll unschedule
- * all events and unset it. When auction params are changed, we'll restart the
- * schedule
- *
- * @type {object | undefined}
- */
-let cancelToken = makeCancelToken();
-
-const waitForRepair = () => {
-  // the params observer will setWakeup to resume.
-  console.warn(
-    '🛠️ No wake for reschedule. Repair by resetting auction params.',
-  );
-};
-
-// Generally, canceling wakups has to be followed by setting up new ones but
-// not in the case of pausing wakeups. We do that in the event of invalid
-// schedule params. When they are repaired by governance, the wakers resume.
-/** @param {ERef<TimerService>} timer */
-const cancelWakeups = timer => {
-  if (cancelToken) {
-    void E(timer).cancel(cancelToken);
-  }
-  cancelToken = undefined;
-};
-
-/**
- * Schedule wakeups for the _next_ auction round.
- *
- * In practice, there are these cases to handle (with N as "live" and N+1 is
- * "next"):
- *
- * | when (now within the range)     | what                                     |
- * | ------------------------------- | ---------------------------------------- |
- * | [start N, nominalStart N+1]     | good: schedule normally the three wakers |
- * | (nominalStart N+1, endTime N+1] | recover: skip round N+1 and schedule N+2 |
- * | (endTime N+1, ∞)                | give up: wait for repair by governance   |
- *
- * @param {object} opts
- * @param {ERef<TimerService>} opts.timer
- * @param {TimerWaker} opts.priceLockWaker
- * @param {TimerWaker} opts.liquidationWaker
- * @param {TimerWaker} opts.reschedulerWaker
- * @param {import('../auction/scheduler.js').Schedule} opts.nextAuctionSchedule
- * @param {import('@agoric/time').TimestampRecord} opts.now
- * @param {ParamStateRecord} opts.params
- * @returns {void}
- */
-const setWakeups = ({
-  nextAuctionSchedule,
-  now,
-  timer,
-  reschedulerWaker,
-  liquidationWaker,
-  priceLockWaker,
-  params,
-}) => {
-  const { startTime, endTime } = nextAuctionSchedule;
-
-  /** @type {RelativeTimeRecord} */
-  // @ts-expect-error Casting
-  // eslint-disable-next-line no-restricted-syntax -- https://github.com/Agoric/eslint-config-jessie/issues/33
-  const priceLockPeriod = params[PRICE_LOCK_PERIOD].value;
-  /** @type {RelativeTimeRecord} */
-  // @ts-expect-error Casting
-  // eslint-disable-next-line no-restricted-syntax -- https://github.com/Agoric/eslint-config-jessie/issues/33
-  const auctionStartDelay = params[AUCTION_START_DELAY].value;
-
-  // nominal is the declared start time, but the actual auctioning begins after auctionStartDelay
-  const nominalStart = TimeMath.subtractAbsRel(startTime, auctionStartDelay);
-
-  // Is there a problem (case 2 or 3)?
-  // setWakeupsForNextAuction is supposed to be called just after an auction
-  // started. If we're late but there's still time for the nominal start, then
-  // we'll proceed. Reschedule for the next round if that's still in the future.
-  // Otherwise, wait for governance params to change.
-  if (TimeMath.compareAbs(now, nominalStart) > 0) {
-    // nominalStart is past, so cancel timers and plan to recover
-    cancelWakeups(timer);
-
-    if (TimeMath.compareAbs(now, endTime) < 0) {
-      // We're currently scheduling the N+1 (where N is live), but we need to skip it.
-      // So wake up for the N+2 round's startTime
-      const afterNextStartTime = TimeMath.addAbsRel(endTime, 1n);
-      trace(
-        'CASE 2: endTime is in the future or now so reschedule waking to startTime of the following round',
-        afterNextStartTime,
-      );
-      void E(timer).setWakeup(afterNextStartTime, reschedulerWaker);
-    } else {
-      trace('CASE 3: endTime is past; wait for repair');
-      waitForRepair();
-    }
-
-    return;
-  }
-  trace('CASE 1: nominalStart is now or in the future');
-
-  cancelToken = cancelToken || makeCancelToken();
-  const priceLockWakeTime = TimeMath.subtractAbsRel(
-    nominalStart,
-    priceLockPeriod,
-  );
-  const a = t => TimeMath.absValue(t);
-  trace('scheduling ', a(priceLockWakeTime), a(nominalStart), a(startTime));
-  void E(timer).setWakeup(priceLockWakeTime, priceLockWaker, cancelToken);
-  void E(timer).setWakeup(nominalStart, liquidationWaker, cancelToken);
-  // Call setWakeupsForNextAuction again one tick after nominalStart
-  const afterStart = TimeMath.addAbsRel(startTime, 1n);
-  void E(timer).setWakeup(afterStart, reschedulerWaker, cancelToken);
-};
-
-/**
- * Schedule wakeups for the _next_ auction round.
- *
- * Called by vaultDirector's resetWakeupsForNextAuction at start() and every
- * time there's a "reschedule" wakeup.
- *
- * @param {ERef<import('../auction/auctioneer.js').AuctioneerPublicFacet>} auctioneerPublicFacet
- * @param {ERef<TimerService>} timer
- * @param {TimerWaker} priceLockWaker
- * @param {TimerWaker} liquidationWaker
- * @param {TimerWaker} reschedulerWaker
- * @returns {Promise<void>}
- */
-export const setWakeupsForNextAuction = async (
-  auctioneerPublicFacet,
-  timer,
-  priceLockWaker,
-  liquidationWaker,
-  reschedulerWaker,
-) => {
-  const [{ nextAuctionSchedule }, params, now] = await Promise.all([
-    E(auctioneerPublicFacet).getSchedules(),
-    E(auctioneerPublicFacet).getGovernedParams(),
-    E(timer).getCurrentTimestamp(),
-  ]);
-
-  trace(
-    'setWakeupsForNextAuction at',
-    now.absValue,
-    'with',
-    nextAuctionSchedule,
-  );
-  if (!nextAuctionSchedule) {
-    // There should always be a nextAuctionSchedule. If there isn't, give up for now.
-    cancelWakeups(timer);
-    waitForRepair();
-    return;
-  }
-
-  setWakeups({
-    nextAuctionSchedule,
-    now,
-    timer,
-    reschedulerWaker,
-    liquidationWaker,
-    priceLockWaker,
-    params,
-  });
-};
-harden(setWakeupsForNextAuction);
-
-/**
- * @param {Amount<'nat'>} debt
- * @param {Amount<'nat'>} minted
- * @returns {{ overage: Amount<'nat'>; shortfall: Amount<'nat'> }}
- */
-export const liquidationResults = (debt, minted) => {
-  if (AmountMath.isEmpty(minted)) {
-    return { overage: minted, shortfall: debt };
-  }
-
-  const [overage, shortfall] = AmountMath.isGTE(debt, minted)
-    ? [AmountMath.makeEmptyFromAmount(debt), AmountMath.subtract(debt, minted)]
-    : [AmountMath.subtract(minted, debt), AmountMath.makeEmptyFromAmount(debt)];
-
-  return { overage, shortfall };
-};
-harden(liquidationResults);
-
-/**
- * Watch governed params for change
- *
- * @param {ERef<import('../auction/auctioneer.js').AuctioneerPublicFacet>} auctioneerPublicFacet
- * @param {ERef<TimerService>} timer
- * @param {TimerWaker} reschedulerWaker
- * @returns {void}
- */
-export const watchForGovernanceChange = (
-  auctioneerPublicFacet,
-  timer,
-  reschedulerWaker,
-) => {
-  void E.when(E(timer).getCurrentTimestamp(), now =>
-    // make one observer that will usually ignore the update.
-    observeIteration(
-      subscribeEach(E(auctioneerPublicFacet).getSubscription()),
-      harden({
-        async updateState(_newState) {
-          if (!cancelToken) {
-            cancelToken = makeCancelToken();
-            void E(timer).setWakeup(
-              // bump one tick to prevent an infinite loop
-              TimeMath.addAbsRel(now, 1n),
-              reschedulerWaker,
-              cancelToken,
-            );
-          }
-        },
-      }),
-    ),
-  );
-};
-
-/**
- * @param {ZCF} zcf
- * @param {object} collateralizationDetails
- * @param {PriceQuote} collateralizationDetails.quote
- * @param {Ratio} collateralizationDetails.interest
- * @param {Ratio} collateralizationDetails.margin
- * @param {ReturnType<
- *   typeof import('./prioritizedVaults.js').makePrioritizedVaults
- * >} prioritizedVaults
- * @param {SetStore<Vault>} liquidatingVaults
- * @param {Brand<'nat'>} debtBrand
- * @param {Brand<'nat'>} collateralBrand
- * @returns {{
- *   vaultData: MapStore<
- *     Vault,
- *     { collateralAmount: Amount<'nat'>; debtAmount: Amount<'nat'> }
- *   >;
- *   totalDebt: Amount<'nat'>;
- *   totalCollateral: Amount<'nat'>;
- *   liqSeat: ZCFSeat;
- * }}
- */
-export const getLiquidatableVaults = (
-  zcf,
-  collateralizationDetails,
-  prioritizedVaults,
-  liquidatingVaults,
-  debtBrand,
-  collateralBrand,
-) => {
-  const vaultsToLiquidate = prioritizedVaults.removeVaultsBelow(
-    collateralizationDetails,
-  );
-  /**
-   * @type {MapStore<
-   *   Vault,
-   *   { collateralAmount: Amount<'nat'>; debtAmount: Amount<'nat'> }
-   * >}
-   */
-  const vaultData = makeScalarMapStore();
-
-  const { zcfSeat: liqSeat } = zcf.makeEmptySeatKit();
-  let totalDebt = AmountMath.makeEmpty(debtBrand);
-  let totalCollateral = AmountMath.makeEmpty(collateralBrand);
-  /** @type {TransferPart[]} */
-  const transfers = [];
-
-  for (const vault of vaultsToLiquidate.values()) {
-    vault.liquidating();
-    liquidatingVaults.add(vault);
-
-    const collateralAmount = vault.getCollateralAmount();
-    totalCollateral = AmountMath.add(totalCollateral, collateralAmount);
-
-    const debtAmount = vault.getCurrentDebt();
-    totalDebt = AmountMath.add(totalDebt, debtAmount);
-    transfers.push([
-      vault.getVaultSeat(),
-      liqSeat,
-      { Collateral: collateralAmount },
-    ]);
-    vaultData.init(vault, { collateralAmount, debtAmount });
-  }
-
-  if (transfers.length > 0) {
-    zcf.atomicRearrange(harden(transfers));
-  }
-
-  return { vaultData, totalDebt, totalCollateral, liqSeat };
-};
-harden(getLiquidatableVaults);

package/src/vaultFactory/proceeds.d.ts

@@ -1,35 +0,0 @@
-export function calculateDistributionPlan({ proceeds, totalDebt, totalCollateral, oraclePriceAtStart, vaultsBalances, penaltyRate, }: {
-    proceeds: AmountKeywordRecord;
-    totalDebt: Amount<"nat">;
-    totalCollateral: Amount<"nat">;
-    oraclePriceAtStart: PriceDescription;
-    vaultsBalances: VaultBalances[];
-    penaltyRate: Ratio;
-}): DistributionPlan;
-/**
- * The plan to execute for distributing proceeds of a liquidation.
- *
- * Vaults are referenced by index in the list sent to the calculator.
- */
-export type DistributionPlan = {
-    overage: Amount<"nat">;
-    shortfallToReserve: Amount<"nat">;
-    collateralForReserve: Amount<"nat">;
-    actualCollateralSold: Amount<"nat">;
-    collateralSold: Amount<"nat">;
-    collatRemaining: Amount<"nat">;
-    debtToBurn: Amount<"nat">;
-    mintedForReserve: Amount<"nat">;
-    mintedProceeds: Amount<"nat">;
-    phantomDebt: Amount<"nat">;
-    totalPenalty: Amount<"nat">;
-    transfersToVault: [number, AmountKeywordRecord][];
-    vaultsToReinstate: number[];
-};
-export type VaultBalances = {
-    collateral: Amount<"nat">;
-    presaleDebt: Amount<"nat">;
-    currentDebt: Amount<"nat">;
-};
-import type { PriceDescription } from '@agoric/zoe/tools/types.js';
-//# sourceMappingURL=proceeds.d.ts.map

package/src/vaultFactory/proceeds.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"proceeds.d.ts","sourceRoot":"","sources":["proceeds.js"],"names":[],"mappings":"AA4DO,sIATJ;IAAoC,QAAQ,EAApC,mBAAmB;IACG,SAAS,EAA/B,MAAM,CAAC,KAAK,CAAC;IACS,eAAe,EAArC,MAAM,CAAC,KAAK,CAAC;IACY,kBAAkB,EAA3C,gBAAgB;IACQ,cAAc,EAAtC,aAAa,EAAE;IAED,WAAW,EAAzB,KAAK;CACb,GAAU,gBAAgB,CA8N5B;;;;;;+BA1QY;IACR,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAClC,oBAAoB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACpC,oBAAoB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACpC,cAAc,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9B,eAAe,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAChC,cAAc,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC3B,YAAY,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC5B,gBAAgB,EAAE,CAAC,MAAM,EAAE,mBAAmB,CAAC,EAAE,CAAC;IAClD,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B;4BAOS;IACR,UAAU,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;CAC5B;sCA5B0F,4BAA4B"}

package/src/vaultFactory/proceeds.js

@@ -1,282 +0,0 @@
-import { AmountMath } from '@agoric/ertp';
-import {
-  ceilDivideBy,
-  ceilMultiplyBy,
-  floorMultiplyBy,
-  makeRatioFromAmounts,
-  multiplyRatios,
-} from '@agoric/zoe/src/contractSupport/index.js';
-import { quoteAsRatio, subtractToEmpty } from '../contractSupport.js';
-import { liquidationResults } from './liquidation.js';
-
-/** @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js'; */
-
-/**
- * @typedef {{
- *   overage: Amount<'nat'>;
- *   shortfallToReserve: Amount<'nat'>;
- *   collateralForReserve: Amount<'nat'>;
- *   actualCollateralSold: Amount<'nat'>;
- *   collateralSold: Amount<'nat'>;
- *   collatRemaining: Amount<'nat'>;
- *   debtToBurn: Amount<'nat'>;
- *   mintedForReserve: Amount<'nat'>;
- *   mintedProceeds: Amount<'nat'>;
- *   phantomDebt: Amount<'nat'>;
- *   totalPenalty: Amount<'nat'>;
- *   transfersToVault: [number, AmountKeywordRecord][];
- *   vaultsToReinstate: number[];
- * }} DistributionPlan
- *   The plan to execute for distributing proceeds of a liquidation.
- *
- *   Vaults are referenced by index in the list sent to the calculator.
- */
-
-/**
- * @typedef {{
- *   collateral: Amount<'nat'>;
- *   presaleDebt: Amount<'nat'>;
- *   currentDebt: Amount<'nat'>;
- * }} VaultBalances
- */
-
-/**
- * Liquidation.md describes how to process liquidation proceeds.
- *
- * This function is complex and may fail. To defend against this possibility, it
- * starts with a base plan and updates it. The updating is the complex portion
- * and is wrapped in a try/catch. If at any point the plan revising fails, the
- * plan is returned as is.
- *
- * @param {object} inputs
- * @param {AmountKeywordRecord} inputs.proceeds
- * @param {Amount<'nat'>} inputs.totalDebt
- * @param {Amount<'nat'>} inputs.totalCollateral
- * @param {PriceDescription} inputs.oraclePriceAtStart
- * @param {VaultBalances[]} inputs.vaultsBalances ordered best to worst
- *   collateralized
- * @param {Ratio} inputs.penaltyRate
- * @returns {DistributionPlan}
- */
-export const calculateDistributionPlan = ({
-  proceeds,
-  totalDebt,
-  totalCollateral,
-  oraclePriceAtStart,
-  vaultsBalances,
-  penaltyRate,
-}) => {
-  const emptyCollateral = AmountMath.makeEmptyFromAmount(totalCollateral);
-  const emptyMinted = AmountMath.makeEmptyFromAmount(totalDebt);
-
-  const { Collateral: collateralProceeds } = proceeds;
-  /** @type {Amount<'nat'>} */
-  const collateralSold = AmountMath.subtract(
-    totalCollateral,
-    collateralProceeds,
-  );
-
-  const mintedProceeds = proceeds.Minted || emptyMinted;
-  const accounting = liquidationResults(totalDebt, mintedProceeds);
-
-  // charged in collateral
-  const totalPenalty = ceilMultiplyBy(
-    totalDebt,
-    multiplyRatios(penaltyRate, quoteAsRatio(oraclePriceAtStart)),
-  );
-
-  const debtPortion = makeRatioFromAmounts(totalPenalty, totalDebt);
-
-  // We mutate the plan so that at any point if there's an error the plan can be returned and executed.
-  // IOW the plan must always be in a valid state, though perhaps incomplete.
-  /** @type {DistributionPlan} */
-  const plan = {
-    overage: accounting.overage,
-    shortfallToReserve: accounting.shortfall,
-    collateralForReserve: emptyCollateral,
-    actualCollateralSold: emptyCollateral,
-    collateralSold,
-    collatRemaining: emptyCollateral,
-    debtToBurn: emptyMinted,
-    mintedForReserve: emptyMinted,
-    mintedProceeds,
-    phantomDebt: emptyMinted,
-    transfersToVault: [],
-    vaultsToReinstate: [],
-    totalPenalty,
-  };
-
-  /**
-   * If interest was charged between liquidating and liquidated, erase it.
-   *
-   * @param {VaultBalances} balances
-   */
-  const updatePhantomDebt = ({ presaleDebt, currentDebt }) => {
-    if (AmountMath.isEqual(presaleDebt, currentDebt)) {
-      return;
-    }
-    const accrued = AmountMath.subtract(currentDebt, presaleDebt);
-    plan.phantomDebt = AmountMath.add(plan.phantomDebt, accrued);
-  };
-
-  const runFlow1 = () => {
-    // Flow #1: no shortfall
-
-    const distributableCollateral = subtractToEmpty(
-      collateralProceeds,
-      totalPenalty,
-    );
-
-    plan.debtToBurn = totalDebt;
-    plan.mintedForReserve = accounting.overage;
-
-    // return remaining funds to vaults before closing
-
-    let leftToStage = distributableCollateral;
-    const price = makeRatioFromAmounts(mintedProceeds, collateralSold);
-
-    // iterate from best to worst, returning collateral until it has
-    // been exhausted. Vaults after that get nothing.
-    for (const [vaultIndex, balances] of vaultsBalances.entries()) {
-      const { collateral: vCollat, presaleDebt } = balances;
-      updatePhantomDebt(balances);
-
-      // max return is vault value reduced by debt and penalty value
-      const debtCollat = ceilDivideBy(presaleDebt, price);
-      const penaltyCollat = ceilMultiplyBy(presaleDebt, debtPortion);
-      const lessCollat = AmountMath.add(debtCollat, penaltyCollat);
-
-      const maxCollat = subtractToEmpty(vCollat, lessCollat);
-      if (!AmountMath.isEmpty(leftToStage)) {
-        const collatReturn = AmountMath.min(leftToStage, maxCollat);
-        leftToStage = AmountMath.subtract(leftToStage, collatReturn);
-        plan.transfersToVault.push([vaultIndex, { Collateral: collatReturn }]);
-      }
-    }
-
-    const hasCollateralToDistribute = !AmountMath.isEmpty(
-      distributableCollateral,
-    );
-    plan.collateralForReserve = hasCollateralToDistribute
-      ? AmountMath.add(leftToStage, totalPenalty)
-      : collateralProceeds;
-  };
-
-  // Flow 2a: all collateral was sold but debt was not covered
-  const runFlow2a = () => {
-    // charge penalty if proceeds are sufficient
-    const penaltyInMinted = ceilMultiplyBy(totalDebt, penaltyRate);
-    const recoveredDebt = AmountMath.min(
-      AmountMath.add(totalDebt, penaltyInMinted),
-      mintedProceeds,
-    );
-
-    plan.debtToBurn = recoveredDebt;
-
-    const distributable = subtractToEmpty(mintedProceeds, recoveredDebt);
-    let mintedRemaining = distributable;
-
-    const vaultPortion = makeRatioFromAmounts(distributable, totalCollateral);
-
-    // iterate from best to worst returning remaining funds to vaults
-    for (const [vaultIndex, balances] of vaultsBalances.entries()) {
-      // from best to worst, return minted above penalty if any remains
-      const vaultShare = floorMultiplyBy(balances.collateral, vaultPortion);
-      updatePhantomDebt(balances);
-
-      if (!AmountMath.isEmpty(mintedRemaining)) {
-        const mintedToReturn = AmountMath.min(mintedRemaining, vaultShare);
-        mintedRemaining = AmountMath.subtract(mintedRemaining, mintedToReturn);
-        plan.transfersToVault.push([vaultIndex, { Minted: mintedToReturn }]);
-      }
-    }
-  };
-
-  // Flow 2b: collateral remains but debt was not covered
-  const runFlow2b = () => {
-    plan.debtToBurn = totalDebt;
-    plan.mintedForReserve = accounting.overage;
-
-    // reconstitute vaults until collateral is insufficient
-    let reconstituteVaults = AmountMath.isGTE(collateralProceeds, totalPenalty);
-
-    // charge penalty if proceeds are sufficient
-    const distributableCollateral = subtractToEmpty(
-      collateralProceeds,
-      totalPenalty,
-    );
-
-    plan.collatRemaining = distributableCollateral;
-
-    let shortfallToReserve = accounting.shortfall;
-    const reduceCollateral = amount =>
-      (plan.actualCollateralSold = AmountMath.add(
-        plan.actualCollateralSold,
-        amount,
-      ));
-
-    // iterate from best to worst attempting to reconstitute, by
-    // returning remaining funds to vaults
-    for (const [vaultIndex, balances] of vaultsBalances.entries()) {
-      const { collateral: vCollat, presaleDebt } = balances;
-
-      // according to #7123, Collateral for penalty =
-      //   total liquidation penalty * vault debt / total debt
-      const vaultPenalty = ceilMultiplyBy(presaleDebt, debtPortion);
-      const collatPostPenalty = subtractToEmpty(vCollat, vaultPenalty);
-      const vaultDebt = floorMultiplyBy(presaleDebt, debtPortion);
-
-      // Should we continue reconstituting vaults?
-      reconstituteVaults =
-        reconstituteVaults &&
-        !AmountMath.isEmpty(collatPostPenalty) &&
-        AmountMath.isGTE(plan.collatRemaining, collatPostPenalty) &&
-        AmountMath.isGTE(totalDebt, presaleDebt);
-
-      if (reconstituteVaults) {
-        plan.collatRemaining = AmountMath.subtract(
-          plan.collatRemaining,
-          collatPostPenalty,
-        );
-        shortfallToReserve = subtractToEmpty(shortfallToReserve, presaleDebt);
-        // must reinstate after atomicRearrange(), so we record them.
-        plan.vaultsToReinstate.push(vaultIndex);
-        reduceCollateral(vaultDebt);
-        plan.transfersToVault.push([
-          vaultIndex,
-          { Collateral: collatPostPenalty },
-        ]);
-      } else {
-        updatePhantomDebt(balances);
-
-        reduceCollateral(vCollat);
-      }
-    }
-
-    plan.collateralForReserve = AmountMath.add(
-      plan.collatRemaining,
-      totalPenalty,
-    );
-
-    plan.shortfallToReserve = shortfallToReserve;
-  };
-
-  try {
-    if (AmountMath.isEmpty(accounting.shortfall)) {
-      // Flow #1: no shortfall
-      runFlow1();
-    } else if (AmountMath.isEmpty(collateralProceeds)) {
-      // Flow 2a: all collateral was sold but debt was not covered
-      runFlow2a();
-    } else {
-      // Flow #2b: There's unsold collateral; some vaults may be reinstated.
-      runFlow2b();
-    }
-  } catch (err) {
-    console.error('🚨 Failure running distribution flow:', err);
-    // continue to return `plan` in the state that was reached
-  }
-
-  return harden(plan);
-};
-harden(calculateDistributionPlan);

package/src/vaultFactory/types-ambient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-ambient.d.ts","sourceRoot":"","sources":["types-ambient.js"],"names":[],"mappings":"+BAGa,OAAO,mBAAmB,EAAE,oBAAoB,CAAC,aAAa,CAAC;;mBAe9D,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,MAAM;wBACxC,MAAM,UAAU;;;;;;;uBAKhB,KAAK;;;;;wBAEL,KAAK;;;;;kBAEL,KAAK;;;;;aAEL,KAAK;eAEL,MAAM,CAAC,KAAK,CAAC;;;;;;;uCAOhB,MAAM,qBACN,OAAO,UACP,uBAAuB,KACrB,OAAO,CAAC,YAAY,CAAC;;kBAKpB,YAAY;yBACZ,MAAM,OAAO,aAAa,EAAE,UAAU;+BACtC,MAAM,OAAO,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;0BACxC,MAAM,OAAO,cAAc,EAAE,UAAU;wBACvC,MAAM,OAAO,cAAc,EAAE,UAAU;;;;;;;;sCAQ1C,OAAO,UACP,MAAM,CAAC,KAAK,CAAC,OACb,MAAM,CAAC,KAAK,CAAC,aACb,YAAY,EAAE,KACZ,IAAI;;;;;yBAMN,MAAM,YACN,OAAO,KACL,IAAI;;0BAKH,MAAM,KAAK;gBACX,MAAM,KAAK;wBACX,MAAM,OAAO,CAAC,OAAO,4BAA4B,EAAE,UAAU,CAAC;;;;;qBAC9D,MAAM,KAAK;;;;;uBAEX,MAAM,YAAY;;;;;wBAElB,MAAM,YAAY;;eAIlB,MAAM;;;;;oBAIN,YAAY;;;;qBACZ,YAAY;;;oBAKZ,MAAM,oBAAoB;kBAC1B,CACT,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,KACR,OAAO,aAAa,EAAE,QAAQ;oBACxB,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC;;;6BAKrC,MAAM,OAAO,CACtB,UAAU,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAA;KAAE,CAAC,CAC9D;;;0BAKU,SAAS;;;;cACT,QAAQ;;;;aACR,QAAQ;;8BAKX,UAAU,eACV,SAAS,KACP,UAAU;;;;;;eAKT,SAAS;;;;;;;8BAET,SAAS;;6BAMT;IAAE,GAAG,EAAE,gBAAgB,GAAG;QAAE,eAAe,EAAE,KAAK,CAAA;KAAE,CAAA;CAAE;uCApIhC,YAAY;2BACxB,YAAY;8BACT,eAAe;kCACX,mBAAmB;uCACd,mBAAmB;qDACL,4BAA4B;6CACpC,4BAA4B;2CAC9B,0BAA0B;+BACtC,cAAc;kCACX,cAAc"}