@agoric/inter-protocol 0.16.2-other-dev-8f8782b.0 → 0.16.2-other-dev-fbe72e7.0.fbe72e7

package/src/vaultFactory/vaultManager.js

@@ -1,22 +1,25 @@
-/* eslint-disable consistent-return */
 /**
  * @file Vault Manager object manages vault-based debts for a collateral type.
  *
- * The responsibilities include:
- * - opening a new vault backed by the collateral
- * - publishing metrics on the vault economy for that collateral
- * - charging interest on all active vaults
- * - liquidating active vaults that have exceeded the debt ratio
+ *   The responsibilities include:
  *
- * Once a vault is settled (liquidated or closed) it can still be used, traded,
- * etc. but is no longer the concern of the manager. It can't be liquidated,
- * have interest charged, or be counted in the metrics.
+ *   - opening a new vault backed by the collateral
+ *   - publishing metrics on the vault economy for that collateral
+ *   - charging interest on all active vaults
+ *   - liquidating active vaults that have exceeded the debt ratio
  *
- * Undercollateralized vaults can have their assets sent to the auctioneer to be
- * liquidated. If the auction is unsuccessful, the liquidation may be reverted.
+ *   Once a vault is settled (liquidated or closed) it can still be used, traded,
+ *   etc. but is no longer the concern of the manager. It can't be liquidated,
+ *   have interest charged, or be counted in the metrics.
+ *
+ *   Undercollateralized vaults can have their assets sent to the auctioneer to be
+ *   liquidated. If the auction is unsuccessful, the liquidation may be
+ *   reverted.
  */
-import '@agoric/zoe/exported.js';
+/// <reference types="@agoric/zoe/exported" />
 
+import { X, Fail, q, makeError } from '@endo/errors';
+import { E } from '@endo/eventual-send';
 import {
   AmountMath,
   AmountShape,
@@ -36,7 +39,6 @@ import {
 } from '@agoric/vat-data';
 import { TransferPartShape } from '@agoric/zoe/src/contractSupport/atomicTransfer.js';
 import {
-  atomicRearrange,
   ceilMultiplyBy,
   floorDivideBy,
   getAmountIn,
@@ -49,8 +51,7 @@ import {
   TopicsRecordShape,
 } from '@agoric/zoe/src/contractSupport/index.js';
 import { PriceQuoteShape, SeatShape } from '@agoric/zoe/src/typeGuards.js';
-import { E } from '@endo/eventual-send';
-import { AuctionPFShape } from '../auction/auctioneer.js';
+import { multiplyBy } from '@agoric/ertp/src/ratio.js';
 import {
   checkDebtLimit,
   makeNatAmountShape,
@@ -62,117 +63,165 @@ import { calculateMinimumCollateralization, minimumPrice } from './math.js';
 import { makePrioritizedVaults } from './prioritizedVaults.js';
 import { Phase, prepareVault } from './vault.js';
 import { calculateDistributionPlan } from './proceeds.js';
+import { AuctionPFShape } from '../auction/auctioneer.js';
 
-const { details: X, Fail, quote: q } = assert;
+/**
+ * @import {MapStore, SetStore} from '@agoric/store';
+ * @import {EReturn} from '@endo/far';
+ * @import {ZCFMint} from '@agoric/zoe';
+ * @import {PriceQuote} from '@agoric/zoe/tools/types.js';
+ */
 
 const trace = makeTracer('VM');
 
-/** @typedef {import('./storeUtils.js').NormalizedDebt} NormalizedDebt */
-/** @typedef {import('@agoric/time/src/types').RelativeTime} RelativeTime */
+/**
+ * Watch a notifier that isn't expected to fail or finish unless the vat hosting
+ * the notifier is upgraded. This watcher supports that by providing a
+ * straightforward way to get a replacement if the notifier breaks.
+ *
+ * @template T notifier topic
+ * @template {any[]} [A=unknown[]] arbitrary arguments
+ * @param {ERef<LatestTopic<T>>} notifierP
+ * @param {import('@agoric/swingset-liveslots').PromiseWatcher<T, A>} watcher
+ * @param {A} args
+ */
+export const watchQuoteNotifier = async (notifierP, watcher, ...args) => {
+  await undefined;
+
+  let updateCount;
+  for (;;) {
+    let value;
+    try {
+      ({ value, updateCount } = await E(notifierP).getUpdateSince(updateCount));
+      watcher.onFulfilled && watcher.onFulfilled(value, ...args);
+    } catch (e) {
+      watcher.onRejected && watcher.onRejected(e, ...args);
+      break;
+    }
+    if (updateCount === undefined) {
+      watcher.onRejected &&
+        watcher.onRejected(Error('stream finished'), ...args);
+      break;
+    }
+  }
+};
+
+/** @import {NormalizedDebt} from './storeUtils.js' */
+/** @import {RelativeTime} from '@agoric/time' */
 
 // Metrics naming scheme: nouns are present values; past-participles are accumulative.
 /**
  * @typedef {object} MetricsNotification
- *
- * @property {Ratio | null} lockedQuote      priceQuote that will be used for liquidation.
- *                                   Non-null from priceLock time until liquidation has taken place.
- * @property {number}         numActiveVaults          present count of vaults
- * @property {number}         numLiquidatingVaults  present count of liquidating vaults
- * @property {Amount<'nat'>}  totalCollateral    present sum of collateral across all vaults
- * @property {Amount<'nat'>}  totalDebt          present sum of debt across all vaults
- * @property {Amount<'nat'>}  retainedCollateral collateral held as a result of not returning excess refunds
- *                                                to owners of vaults liquidated with shortfalls
- * @property {Amount<'nat'>}  liquidatingCollateral  present sum of collateral in vaults sent for liquidation
- * @property {Amount<'nat'>}  liquidatingDebt        present sum of debt in vaults sent for liquidation
- *
- * @property {Amount<'nat'>}  totalCollateralSold       running sum of collateral sold in liquidation
- * @property {Amount<'nat'>}  totalOverageReceived      running sum of overages, central received greater than debt
- * @property {Amount<'nat'>}  totalProceedsReceived     running sum of minted received from liquidation
- * @property {Amount<'nat'>}  totalShortfallReceived    running sum of shortfalls, minted received less than debt
- * @property {number}         numLiquidationsCompleted  running count of liquidated vaults
- * @property {number}         numLiquidationsAborted    running count of vault liquidations that were reverted.
+ * @property {Ratio | null} lockedQuote priceQuote that will be used for
+ *   liquidation. Non-null from priceLock time until liquidation has taken
+ *   place.
+ * @property {number} numActiveVaults present count of vaults
+ * @property {number} numLiquidatingVaults present count of liquidating vaults
+ * @property {Amount<'nat'>} totalCollateral present sum of collateral across
+ *   all vaults
+ * @property {Amount<'nat'>} totalDebt present sum of debt across all vaults
+ * @property {Amount<'nat'>} retainedCollateral collateral held as a result of
+ *   not returning excess refunds to owners of vaults liquidated with
+ *   shortfalls
+ * @property {Amount<'nat'>} liquidatingCollateral present sum of collateral in
+ *   vaults sent for liquidation
+ * @property {Amount<'nat'>} liquidatingDebt present sum of debt in vaults sent
+ *   for liquidation
+ * @property {Amount<'nat'>} totalCollateralSold running sum of collateral sold
+ *   in liquidation
+ * @property {Amount<'nat'>} totalOverageReceived running sum of overages,
+ *   central received greater than debt
+ * @property {Amount<'nat'>} totalProceedsReceived running sum of minted
+ *   received from liquidation
+ * @property {Amount<'nat'>} totalShortfallReceived running sum of shortfalls,
+ *   minted received less than debt
+ * @property {number} numLiquidationsCompleted running count of liquidated
+ *   vaults
+ * @property {number} numLiquidationsAborted running count of vault liquidations
+ *   that were reverted.
  */
 
 /**
  * @typedef {{
- *  compoundedInterest: Ratio,
- *  interestRate: Ratio,
- *  latestInterestUpdate: Timestamp,
+ *   compoundedInterest: Ratio;
+ *   interestRate: Ratio;
+ *   latestInterestUpdate: Timestamp;
  * }} AssetState
  *
+ *
  * @typedef {{
- *  getChargingPeriod: () => RelativeTime,
- *  getRecordingPeriod: () => RelativeTime,
- *  getDebtLimit: () => Amount<'nat'>,
- *  getInterestRate: () => Ratio,
- *  getLiquidationPadding: () => Ratio,
- *  getLiquidationMargin: () => Ratio,
- *  getLiquidationPenalty: () => Ratio,
- *  getMintFee: () => Ratio,
- *  getMinInitialDebt: () => Amount<'nat'>,
+ *   getChargingPeriod: () => RelativeTime;
+ *   getRecordingPeriod: () => RelativeTime;
+ *   getDebtLimit: () => Amount<'nat'>;
+ *   getInterestRate: () => Ratio;
+ *   getLiquidationPadding: () => Ratio;
+ *   getLiquidationMargin: () => Ratio;
+ *   getLiquidationPenalty: () => Ratio;
+ *   getMintFee: () => Ratio;
+ *   getMinInitialDebt: () => Amount<'nat'>;
  * }} GovernedParamGetters
  */
 
 /**
  * @typedef {Readonly<{
- *   debtMint: ZCFMint<'nat'>,
- *   collateralBrand: Brand<'nat'>,
- *   collateralUnit: Amount<'nat'>,
- *   descriptionScope: string,
- *   startTimeStamp: Timestamp,
- *   storageNode: StorageNode,
+ *   debtMint: ZCFMint<'nat'>;
+ *   collateralBrand: Brand<'nat'>;
+ *   collateralUnit: Amount<'nat'>;
+ *   descriptionScope: string;
+ *   startTimeStamp: Timestamp;
+ *   storageNode: StorageNode;
  * }>} HeldParams
  */
 
 /**
  * @typedef {{
- *   assetTopicKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<AssetState>,
- *   debtBrand: Brand<'nat'>,
- *   liquidatingVaults: SetStore<Vault>,
- *   metricsTopicKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<MetricsNotification>,
- *   poolIncrementSeat: ZCFSeat,
- *   retainedCollateralSeat: ZCFSeat,
- *   unsettledVaults: MapStore<string, Vault>,
+ *   assetTopicKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<AssetState>;
+ *   debtBrand: Brand<'nat'>;
+ *   liquidatingVaults: SetStore<Vault>;
+ *   metricsTopicKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<MetricsNotification>;
+ *   poolIncrementSeat: ZCFSeat;
+ *   retainedCollateralSeat: ZCFSeat;
+ *   unsettledVaults: MapStore<string, Vault>;
  * }} ImmutableState
  */
 
 /**
  * @typedef {{
- *   compoundedInterest: Ratio,
- *   latestInterestUpdate: Timestamp,
- *   numLiquidationsCompleted: number,
- *   numLiquidationsAborted: number,
- *   totalCollateral: Amount<'nat'>,
- *   totalCollateralSold: Amount<'nat'>,
- *   totalDebt: Amount<'nat'>,
- *   liquidatingCollateral: Amount<'nat'>,
- *   liquidatingDebt: Amount<'nat'>,
- *   totalOverageReceived: Amount<'nat'>,
- *   totalProceedsReceived: Amount<'nat'>,
- *   totalShortfallReceived: Amount<'nat'>,
- *   vaultCounter: number,
- *   lockedQuote: PriceQuote | undefined,
+ *   compoundedInterest: Ratio;
+ *   latestInterestUpdate: Timestamp;
+ *   numLiquidationsCompleted: number;
+ *   numLiquidationsAborted: number;
+ *   totalCollateral: Amount<'nat'>;
+ *   totalCollateralSold: Amount<'nat'>;
+ *   totalDebt: Amount<'nat'>;
+ *   liquidatingCollateral: Amount<'nat'>;
+ *   liquidatingDebt: Amount<'nat'>;
+ *   totalOverageReceived: Amount<'nat'>;
+ *   totalProceedsReceived: Amount<'nat'>;
+ *   totalShortfallReceived: Amount<'nat'>;
+ *   vaultCounter: number;
+ *   lockedQuote: PriceQuote | undefined;
  * }} MutableState
  */
 
 /**
  * @type {(brand: Brand) => {
- * prioritizedVaults: ReturnType<typeof makePrioritizedVaults>,
- * storedQuotesNotifier: import('@agoric/notifier').StoredNotifier<PriceQuote>,
- * storedCollateralQuote: PriceQuote,
+ *   prioritizedVaults: ReturnType<typeof makePrioritizedVaults>;
+ *   storedQuotesNotifier: import('@agoric/notifier').StoredNotifier<PriceQuote>;
+ *   storedCollateralQuote: PriceQuote | null;
  * }}
  */
 // any b/c will be filled after start()
 const collateralEphemera = makeEphemeraProvider(() => /** @type {any} */ ({}));
 
 /**
- * @param {import('@agoric/ertp').Baggage} baggage
+ * @param {import('@agoric/swingset-liveslots').Baggage} baggage
  * @param {{
- *   zcf: import('./vaultFactory.js').VaultFactoryZCF,
- *   marshaller: ERef<Marshaller>,
- *   makeRecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit,
- *   makeERecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').MakeERecorderKit,
- *   factoryPowers: import('./vaultDirector.js').FactoryPowersFacet,
+ *   zcf: import('./vaultFactory.js').VaultFactoryZCF;
+ *   marshaller: ERef<Marshaller>;
+ *   makeRecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit;
+ *   makeERecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').MakeERecorderKit;
+ *   factoryPowers: import('./vaultDirector.js').FactoryPowersFacet;
  * }} powers
  */
 export const prepareVaultManagerKit = (
@@ -180,6 +229,7 @@ export const prepareVaultManagerKit = (
   { zcf, marshaller, makeRecorderKit, factoryPowers },
 ) => {
   const { priceAuthority, timerService, reservePublicFacet } = zcf.getTerms();
+  const watchedBrands = new Set();
 
   const makeVault = prepareVault(baggage, makeRecorderKit, zcf);
 
@@ -203,8 +253,9 @@ export const prepareVaultManagerKit = (
       poolIncrementSeat: zcf.makeEmptySeatKit().zcfSeat,
 
       /**
-       * Vaults that have been sent for liquidation. When we get proceeds (or lack
-       * thereof) back from the liquidator, we will allocate them among the vaults.
+       * Vaults that have been sent for liquidation. When we get proceeds (or
+       * lack thereof) back from the liquidator, we will allocate them among the
+       * vaults.
        *
        * @type {SetStore<Vault>}
        */
@@ -292,7 +343,7 @@ export const prepareVaultManagerKit = (
         getCollateralQuote: M.call().returns(PriceQuoteShape),
         getPublicFacet: M.call().returns(M.remotable('publicFacet')),
         lockOraclePrices: M.call().returns(PriceQuoteShape),
-        liquidateVaults: M.call(AuctionPFShape).returns(M.promise()),
+        liquidateVaults: M.call(M.eref(AuctionPFShape)).returns(M.promise()),
       }),
     },
     initState,
@@ -339,19 +390,11 @@ export const prepareVaultManagerKit = (
 
       // Some of these could go in closures but are kept on a facet anticipating future durability options.
       helper: {
-        /**
-         * Start non-durable processes (or restart if needed after vat restart)
-         */
+        /** Start non-durable processes (or restart if needed after vat restart) */
         start() {
           const { state, facets } = this;
           trace(state.collateralBrand, 'helper.start()', state.vaultCounter);
-          const {
-            collateralBrand,
-            collateralUnit,
-            debtBrand,
-            storageNode,
-            unsettledVaults,
-          } = state;
+          const { collateralBrand, unsettledVaults } = state;
 
           const ephemera = collateralEphemera(collateralBrand);
           ephemera.prioritizedVaults = makePrioritizedVaults(unsettledVaults);
@@ -374,44 +417,81 @@ export const prepareVaultManagerKit = (
                 ),
             fail: reason => {
               zcf.shutdownWithFailure(
-                assert.error(X`Unable to continue without a timer: ${reason}`),
+                makeError(X`Unable to continue without a timer: ${reason}`),
               );
             },
             finish: done => {
               zcf.shutdownWithFailure(
-                assert.error(X`Unable to continue without a timer: ${done}`),
+                makeError(X`Unable to continue without a timer: ${done}`),
               );
             },
           });
 
-          trace('helper.start() making quoteNotifier from', priceAuthority);
-          const quoteNotifier = E(priceAuthority).makeQuoteNotifier(
+          void facets.helper.ensureQuoteNotifierWatched();
+
+          trace('helper.start() done');
+        },
+        ensureQuoteNotifierWatched() {
+          const { state } = this;
+
+          const { collateralBrand, collateralUnit, debtBrand, storageNode } =
+            state;
+          if (watchedBrands.has(collateralBrand)) {
+            return;
+          }
+          watchedBrands.add(collateralBrand);
+
+          const ephemera = collateralEphemera(collateralBrand);
+
+          const quoteNotifierP = E(priceAuthority).makeQuoteNotifier(
             collateralUnit,
             debtBrand,
           );
-          ephemera.storedQuotesNotifier = makeStoredNotifier(
-            quoteNotifier,
-            E(storageNode).makeChildNode('quotes'),
-            marshaller,
-          );
-          trace('helper.start() awaiting observe storedQuotesNotifier');
-          // NB: upon restart, there may not be a price for a while. If manager
-          // operations are permitted, ones the depend on price information will
-          // throw. See https://github.com/Agoric/agoric-sdk/issues/4317
-          void observeNotifier(quoteNotifier, {
-            updateState(value) {
-              trace('vaultManager got new collateral quote', value);
-              ephemera.storedCollateralQuote = value;
+
+          void E.when(
+            quoteNotifierP,
+            quoteNotifier => {
+              // @ts-expect-error XXX quotes
+              ephemera.storedQuotesNotifier = makeStoredNotifier(
+                // @ts-expect-error XXX quotes
+                quoteNotifier,
+                E(storageNode).makeChildNode('quotes'),
+                marshaller,
+              );
+              trace(
+                'helper.start() awaiting observe storedQuotesNotifier',
+                collateralBrand,
+              );
+              // NB: upon restart, there may not be a price for a while. If manager
+              // operations are permitted, ones that depend on price information
+              // will throw. See https://github.com/Agoric/agoric-sdk/issues/4317
+              const quoteWatcher = harden({
+                onFulfilled(value) {
+                  trace('watcher updated price', value);
+                  ephemera.storedCollateralQuote = value;
+                },
+                onRejected() {
+                  // NOTE: drastic action, if the quoteNotifier fails, we don't know
+                  // the value of the asset, nor do we know how long we'll be in
+                  // ignorance. Best choice is to disable actions that require
+                  // prices and restart when we have a new price. If we restart the
+                  // notifier immediately, we'll trigger an infinite loop, so try
+                  // to restart each time we get a request.
+
+                  ephemera.storedCollateralQuote = null;
+                  watchedBrands.delete(collateralBrand);
+                },
+              });
+              void watchQuoteNotifier(quoteNotifier, quoteWatcher);
             },
-            fail(reason) {
-              console.error('quoteNotifier failed to iterate', reason);
+            e => {
+              trace('makeQuoteNotifier failed, resetting', e);
+              ephemera.storedCollateralQuote = null;
+              watchedBrands.delete(collateralBrand);
             },
-          });
-          trace('helper.start() done');
+          );
         },
-        /**
-         * @param {Timestamp} updateTime
-         */
+        /** @param {Timestamp} updateTime */
         async chargeAllVaults(updateTime) {
           const { state, facets } = this;
           const { collateralBrand, debtMint, poolIncrementSeat } = state;
@@ -515,7 +595,6 @@ export const prepareVaultManagerKit = (
           state.liquidatingDebt = AmountMath.add(state.liquidatingDebt, debt);
         },
         /**
-         *
          * @param {Amount<'nat'>} debt
          * @param {Amount<'nat'>} collateral
          * @param {Amount<'nat'>} overage
@@ -598,14 +677,18 @@ export const prepareVaultManagerKit = (
         },
 
         /**
-         * This is designed to tolerate an incomplete plan, in case calculateDistributionPlan encounters
-         * an error during its calculation. We don't have a way to induce such errors in CI so we've
-         * done so manually in dev and verified this function recovers as expected.
+         * This is designed to tolerate an incomplete plan, in case
+         * calculateDistributionPlan encounters an error during its calculation.
+         * We don't have a way to induce such errors in CI so we've done so
+         * manually in dev and verified this function recovers as expected.
          *
          * @param {AmountKeywordRecord} proceeds
          * @param {Amount<'nat'>} totalDebt
          * @param {Pick<PriceQuote, 'quoteAmount'>} oraclePriceAtStart
-         * @param {MapStore<Vault, { collateralAmount: Amount<'nat'>, debtAmount:  Amount<'nat'>}>} vaultData
+         * @param {MapStore<
+         *   Vault,
+         *   { collateralAmount: Amount<'nat'>; debtAmount: Amount<'nat'> }
+         * >} vaultData
          * @param {Amount<'nat'>} totalCollateral
          */
         planProceedsDistribution(
@@ -661,13 +744,14 @@ export const prepareVaultManagerKit = (
         },
 
         /**
-         * This is designed to tolerate an incomplete plan, in case calculateDistributionPlan encounters
-         * an error during its calculation. We don't have a way to induce such errors in CI so we've
-         * done so manually in dev and verified this function recovers as expected.
+         * This is designed to tolerate an incomplete plan, in case
+         * calculateDistributionPlan encounters an error during its calculation.
+         * We don't have a way to induce such errors in CI so we've done so
+         * manually in dev and verified this function recovers as expected.
          *
          * @param {object} obj
          * @param {import('./proceeds.js').DistributionPlan} obj.plan
-         * @param {Array<Vault>} obj.vaultsInPlan
+         * @param {Vault[]} obj.vaultsInPlan
          * @param {ZCFSeat} obj.liqSeat
          * @param {Amount<'nat'>} obj.totalCollateral
          * @param {Amount<'nat'>} obj.totalDebt
@@ -687,13 +771,13 @@ export const prepareVaultManagerKit = (
           if (plan.transfersToVault.length > 0) {
             const transfers = plan.transfersToVault.map(
               ([vaultIndex, amounts]) =>
-                /** @type {import('@agoric/zoe/src/contractSupport/atomicTransfer.js').TransferPart} */ ([
+                /** @type {TransferPart} */ ([
                   liqSeat,
                   vaultsInPlan[vaultIndex].getVaultSeat(),
                   amounts,
                 ]),
             );
-            atomicRearrange(zcf, harden(transfers));
+            zcf.atomicRearrange(harden(transfers));
           }
 
           const { prioritizedVaults } = collateralEphemera(
@@ -773,10 +857,15 @@ export const prepareVaultManagerKit = (
          * @param {Amount<'nat'>} collateralAmount
          */
         maxDebtFor(collateralAmount) {
-          const { collateralBrand } = this.state;
+          const { state, facets } = this;
+          const { collateralBrand } = state;
           const { storedCollateralQuote } = collateralEphemera(collateralBrand);
-          if (!storedCollateralQuote)
-            throw Fail`maxDebtFor called before a collateral quote was available`;
+          if (!storedCollateralQuote) {
+            facets.helper.ensureQuoteNotifierWatched();
+
+            // it might take an arbitrary amount of time to get a new quote
+            throw Fail`maxDebtFor called before a collateral quote was available for ${collateralBrand}`;
+          }
           // use the lower price to prevent vault adjustments that put them imminently underwater
           const collateralPrice = minimumPrice(
             storedCollateralQuote,
@@ -840,9 +929,7 @@ export const prepareVaultManagerKit = (
           const { descriptionScope } = this.state;
           return `${descriptionScope}: ${base}`;
         },
-        /**
-         * coefficient on existing debt to calculate new debt
-         */
+        /** coefficient on existing debt to calculate new debt */
         getCompoundedInterest() {
           return this.state.compoundedInterest;
         },
@@ -852,7 +939,8 @@ export const prepareVaultManagerKit = (
          * @param {NormalizedDebt} oldDebtNormalized
          * @param {Amount<'nat'>} oldCollateral
          * @param {VaultId} vaultId
-         * @param {import('./vault.js').VaultPhase} vaultPhase at the end of whatever change updated balances
+         * @param {import('./vault.js').VaultPhase} vaultPhase at the end of
+         *   whatever change updated balances
          * @param {Vault} vault
          * @returns {void}
          */
@@ -926,8 +1014,9 @@ export const prepareVaultManagerKit = (
           );
           state.totalDebt = AmountMath.subtract(
             AmountMath.add(state.totalDebt, vault.getCurrentDebt()),
-            oldDebtNormalized,
+            multiplyBy(oldDebtNormalized, state.compoundedInterest),
           );
+
           void facets.helper.writeMetrics();
         },
       },
@@ -937,9 +1026,7 @@ export const prepareVaultManagerKit = (
           return factoryPowers.getGovernedParams(collateralBrand);
         },
 
-        /**
-         * @param {ZCFSeat} seat
-         */
+        /** @param {ZCFSeat} seat */
         async makeVaultKit(seat) {
           const {
             state,
@@ -963,7 +1050,6 @@ export const prepareVaultManagerKit = (
 
           try {
             // TODO `await` is allowed until the above ordering is fixed
-            // eslint-disable-next-line @jessie.js/no-nested-await
             const vaultKit = await vault.initVaultKit(seat, vaultStorageNode);
             // initVaultKit calls back to handleBalanceChange() which will add the
             // vault to prioritizedVaults
@@ -1017,11 +1103,17 @@ export const prepareVaultManagerKit = (
         },
 
         getCollateralQuote() {
+          const { state, facets } = this;
           const { storedCollateralQuote } = collateralEphemera(
-            this.state.collateralBrand,
+            state.collateralBrand,
           );
-          if (!storedCollateralQuote)
+          if (!storedCollateralQuote) {
+            facets.helper.ensureQuoteNotifierWatched();
+
+            // it might take an arbitrary amount of time to get a new quote
             throw Fail`getCollateralQuote called before a collateral quote was available`;
+          }
+
           return storedCollateralQuote;
         },
 
@@ -1034,21 +1126,24 @@ export const prepareVaultManagerKit = (
           const { storedCollateralQuote } = collateralEphemera(
             state.collateralBrand,
           );
-          if (!storedCollateralQuote)
-            throw Fail`lockOraclePrices called before a collateral quote was available`;
+          if (!storedCollateralQuote) {
+            facets.helper.ensureQuoteNotifierWatched();
+
+            // it might take an arbitrary amount of time to get a new quote
+            throw Fail`lockOraclePrices called before a collateral quote was available for ${state.collateralBrand}`;
+          }
+
           trace(
-            `lockPrice`,
+            `lockOraclePrices`,
             getAmountIn(storedCollateralQuote),
             getAmountOut(storedCollateralQuote),
           );
 
           state.lockedQuote = storedCollateralQuote;
-          facets.helper.writeMetrics();
+          void facets.helper.writeMetrics();
           return storedCollateralQuote;
         },
-        /**
-         * @param {AuctioneerPublicFacet} auctionPF
-         */
+        /** @param {ERef<AuctioneerPublicFacet>} auctionPF */
         async liquidateVaults(auctionPF) {
           const { state, facets } = this;
           const { self, helper } = facets;
@@ -1061,11 +1156,28 @@ export const prepareVaultManagerKit = (
           } = state;
           trace(collateralBrand, 'considering liquidation');
 
+          if (!lockedQuote) {
+            // By design, the first cycle of auction may call this before a quote is locked
+            // because the schedule is global at the vaultDirector level, and if a manager
+            // starts after the price lock time there's nothing to be done.
+            // NB: this message should not log repeatedly.
+            console.error(
+              'Skipping liquidation because no quote is locked yet (may happen with new manager)',
+            );
+            return;
+          }
+
+          const { storedCollateralQuote: collateralQuoteBefore } =
+            collateralEphemera(this.state.collateralBrand);
+          if (!collateralQuoteBefore) {
+            console.error(
+              'Skipping liquidation because collateralQuote is missing',
+            );
+            return;
+          }
+
           const { prioritizedVaults } = collateralEphemera(collateralBrand);
-          assert(factoryPowers && prioritizedVaults && zcf);
-          lockedQuote ||
-            Fail`Must have locked a quote before liquidating vaults.`;
-          assert(lockedQuote); // redundant with previous line
+          prioritizedVaults || Fail`prioritizedVaults missing from ephemera`;
 
           const liqMargin = self.getGovernedParams().getLiquidationMargin();
 
@@ -1087,6 +1199,7 @@ export const prepareVaultManagerKit = (
           state.lockedQuote = undefined;
 
           if (vaultData.getSize() === 0) {
+            void helper.writeMetrics();
             return;
           }
           trace(
@@ -1126,7 +1239,10 @@ export const prepareVaultManagerKit = (
             const { plan, vaultsInPlan } = helper.planProceedsDistribution(
               proceeds,
               totalDebt,
-              storedCollateralQuote,
+              // If a quote was available at the start of liquidation, but is no
+              // longer, using the earlier price is better than failing to
+              // distribute proceeds
+              storedCollateralQuote || collateralQuoteBefore,
               vaultData,
               totalCollateral,
             );
@@ -1150,7 +1266,7 @@ export const prepareVaultManagerKit = (
             liquidatingVaults.delete(vault);
           }
 
-          await facets.helper.writeMetrics();
+          void helper.writeMetrics();
         },
       },
     },
@@ -1174,7 +1290,12 @@ export const prepareVaultManagerKit = (
     },
   );
 
-  /** @param {Omit<Parameters<typeof makeVaultManagerKitInternal>[0], 'metricsStorageNode'>} externalParams */
+  /**
+   * @param {Omit<
+   *   Parameters<typeof makeVaultManagerKitInternal>[0],
+   *   'metricsStorageNode'
+   * >} externalParams
+   */
   const makeVaultManagerKit = async externalParams => {
     const metricsStorageNode = await E(
       externalParams.storageNode,
@@ -1187,15 +1308,13 @@ export const prepareVaultManagerKit = (
   return makeVaultManagerKit;
 };
 
+/** @typedef {EReturn<EReturn<typeof prepareVaultManagerKit>>} VaultManagerKit */
 /**
- * @typedef {Awaited<ReturnType<ReturnType<typeof prepareVaultManagerKit>>>} VaultManagerKit
- */
-/**
- * @typedef {VaultManagerKit['self']} VaultManager
- * Each VaultManager manages a single collateral type.
+ * @typedef {VaultManagerKit['self']} VaultManager Each VaultManager manages a
+ *   single collateral type.
  *
- * It manages some number of outstanding debt positions, each called a Vault,
- * for which the collateral is provided in exchange for borrowed Minted.
+ *   It manages some number of outstanding debt positions, each called a Vault,
+ *   for which the collateral is provided in exchange for borrowed Minted.
  */
 /** @typedef {VaultManagerKit['collateral']} CollateralManager */