@agoric/inter-protocol 0.13.2-dev-606cbd2.0 → 0.13.2-dev-8d17cce.0

package/src/vaultFactory/liquidation.js

@@ -1,13 +1,15 @@
 // @jessie-check
 
-import { E } from '@endo/eventual-send';
 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 { atomicRearrange } from '@agoric/zoe/src/contractSupport/index.js';
-import { makeScalarMapStore } from '@agoric/store';
+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', false);
 
@@ -16,32 +18,65 @@ const trace = makeTracer('LIQ', false);
 /** @typedef {import('@agoric/time/src/types').CancelToken} CancelToken */
 /** @typedef {import('@agoric/time/src/types').RelativeTimeRecord} RelativeTimeRecord */
 
+const makeCancelToken = makeCancelTokenMaker('liq');
+
 /**
- * @param {ERef<import('../auction/auctioneer.js').AuctioneerPublicFacet>} auctioneerPublicFacet
- * @param {ERef<TimerService>} timer
- * @param {TimerWaker} priceLockWaker
- * @param {TimerWaker} liquidationWaker
- * @param {TimerWaker} reschedulerWaker
+ * 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}
  */
-const scheduleLiquidationWakeups = async (
-  auctioneerPublicFacet,
-  timer,
-  priceLockWaker,
-  liquidationWaker,
-  reschedulerWaker,
-) => {
-  const [schedules, params] = await Promise.all([
-    E(auctioneerPublicFacet).getSchedules(),
-    E(auctioneerPublicFacet).getGovernedParams(),
-  ]);
+let cancelToken = makeCancelToken();
 
-  trace('SCHEDULE', schedules.nextAuctionSchedule);
-  if (!schedules.nextAuctionSchedule?.startTime) {
-    // The schedule says there's no next auction.
-    return;
+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;
+};
 
-  const { startTime } = schedules.nextAuctionSchedule;
+/**
+ * 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/src/types').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
@@ -52,17 +87,87 @@ const scheduleLiquidationWakeups = async (
   // 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);
+  const afterStart = TimeMath.addAbsRel(startTime, 1n);
+
+  // 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
+    cancelWakeups(timer);
+
+    if (TimeMath.compareAbs(now, endTime) < 0) {
+      // endTime is in the future or now to reschedule waking (case 2)
+      void E(timer).setWakeup(afterStart, reschedulerWaker);
+    } else {
+      // case 3
+      waitForRepair();
+    }
+
+    return;
+  }
+  // nominalStart is now or in the future (case 1)
+
+  cancelToken = cancelToken || makeCancelToken();
   const priceLockWakeTime = TimeMath.subtractAbsRel(
     nominalStart,
     priceLockPeriod,
   );
-  const afterStart = TimeMath.addAbsRel(startTime, 1n);
   const a = t => TimeMath.absValue(t);
   trace('scheduling ', a(priceLockWakeTime), a(nominalStart), a(startTime));
-  void E(timer).setWakeup(priceLockWakeTime, priceLockWaker);
-  void E(timer).setWakeup(nominalStart, liquidationWaker);
-  void E(timer).setWakeup(afterStart, reschedulerWaker);
+  void E(timer).setWakeup(priceLockWakeTime, priceLockWaker, cancelToken);
+  void E(timer).setWakeup(nominalStart, liquidationWaker, cancelToken);
+  // Call setWakeupsForNextAuction again one tick after nominalStart
+  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>}
+ */
+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('SCHEDULE', 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,
+  });
 };
 
 /**
@@ -94,6 +199,40 @@ const liquidationResults = (debt, minted) => {
   };
 };
 
+/**
+ * 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
@@ -154,12 +293,8 @@ const getLiquidatableVaults = (
   return { vaultData, totalDebt, totalCollateral, liqSeat };
 };
 
-harden(scheduleLiquidationWakeups);
+harden(setWakeupsForNextAuction);
 harden(liquidationResults);
 harden(getLiquidatableVaults);
 
-export {
-  scheduleLiquidationWakeups,
-  liquidationResults,
-  getLiquidatableVaults,
-};
+export { setWakeupsForNextAuction, liquidationResults, getLiquidatableVaults };

package/src/vaultFactory/vault.js

@@ -85,7 +85,7 @@ const validTransitions = {
  * @property {(base: string) => string} scopeDescription
  * @property {() => Brand<'nat'>} getDebtBrand
  * @property {MintAndTransfer} mintAndTransfer
- * @property {(amount: Amount, seat: ZCFSeat) => void} burnAndRecord
+ * @property {(amount: Amount, seat: ZCFSeat) => void} burn
  * @property {() => Ratio} getCompoundedInterest
  * @property {(oldDebt: import('./storeUtils.js').NormalizedDebt, oldCollateral: Amount<'nat'>, vaultId: VaultId, vaultPhase: VaultPhase, vault: Vault) => void} handleBalanceChange
  * @property {() => import('./vaultManager.js').GovernedParamGetters} getGovernedParams
@@ -350,7 +350,8 @@ export const prepareVault = (baggage, makeRecorderKit, zcf) => {
           }
           const { phase } = state;
           const uiState = facets.helper.getStateSnapshot(phase);
-          trace('updateUiState', state.idInManager, uiState);
+          const brand = facets.helper.collateralBrand();
+          trace(brand, 'updateUiState', state.idInManager, uiState);
 
           switch (phase) {
             case Phase.ACTIVE:
@@ -404,7 +405,7 @@ export const prepareVault = (baggage, makeRecorderKit, zcf) => {
               vaultSeat.getCurrentAllocation(),
             );
 
-            state.manager.burnAndRecord(debt, seat);
+            state.manager.burn(debt, seat);
           } else if (phase === Phase.LIQUIDATED) {
             // Simply reallocate vault assets to the offer seat.
             // Don't take anything from the offer, even if vault is underwater.
@@ -558,7 +559,7 @@ export const prepareVault = (baggage, makeRecorderKit, zcf) => {
             collateralPre,
             newDebt,
           );
-          state.manager.burnAndRecord(giveMintedTaken, vaultSeat);
+          state.manager.burn(giveMintedTaken, vaultSeat);
           helper.assertVaultHoldsNoMinted();
 
           helper.updateUiState();

package/src/vaultFactory/vaultDirector.js

@@ -27,7 +27,10 @@ import {
 import { E } from '@endo/eventual-send';
 import { Far } from '@endo/marshal';
 import { makeCollectFeesInvitation } from '../collectFees.js';
-import { scheduleLiquidationWakeups } from './liquidation.js';
+import {
+  setWakeupsForNextAuction,
+  watchForGovernanceChange,
+} from './liquidation.js';
 import {
   provideVaultParamManagers,
   SHORTFALL_INVITATION_KEY,
@@ -135,7 +138,7 @@ export const prepareVaultDirector = (
       rewardPoolAllocation: rewardPoolSeat.getCurrentAllocation(),
     });
   };
-  const updateMetrics = () => E(metricsKit.recorderP).write(sampleMetrics());
+  const writeMetrics = () => E(metricsKit.recorderP).write(sampleMetrics());
 
   const updateShortfallReporter = async () => {
     const oldInvitation = baggage.has(shortfallInvitationKey)
@@ -212,7 +215,7 @@ export const prepareVaultDirector = (
         debtMint.burnLosses(harden({ Minted: toMint }), mintSeat);
         throw e;
       }
-      void updateMetrics();
+      void writeMetrics();
     },
     getShortfallReporter: async () => {
       await updateShortfallReporter();
@@ -310,7 +313,7 @@ export const prepareVaultDirector = (
         getPublicTopics: M.call().returns(TopicsRecordShape),
       }),
       helper: M.interface('helper', {
-        rescheduleLiquidationWakeups: M.call().returns(M.promise()),
+        resetWakeupsForNextAuction: M.call().returns(M.promise()),
         start: M.call().returns(M.promise()),
       }),
     },
@@ -408,7 +411,7 @@ export const prepareVaultDirector = (
           const { self: vm } = kit;
           vm || Fail`no vault`;
           collateralManagers.init(collateralBrand, managerIndex);
-          void updateMetrics();
+          void writeMetrics();
           return vm;
         },
         makeCollectFeesInvitation() {
@@ -432,7 +435,7 @@ export const prepareVaultDirector = (
         makeReschedulerWaker() {
           const { facets } = this;
           return makeWaker('reschedulerWaker', () => {
-            void facets.helper.rescheduleLiquidationWakeups();
+            void facets.helper.resetWakeupsForNextAuction();
           });
         },
         makePriceLockWaker() {
@@ -520,13 +523,13 @@ export const prepareVaultDirector = (
         },
       },
       helper: {
-        rescheduleLiquidationWakeups() {
+        resetWakeupsForNextAuction() {
           const { facets } = this;
 
           const priceLockWaker = facets.machine.makePriceLockWaker();
           const liquidationWaker = facets.machine.makeLiquidationWaker();
           const rescheduleWaker = facets.machine.makeReschedulerWaker();
-          return scheduleLiquidationWakeups(
+          return setWakeupsForNextAuction(
             auctioneer,
             timer,
             priceLockWaker,
@@ -538,9 +541,18 @@ export const prepareVaultDirector = (
          * Start non-durable processes (or restart if needed after vat restart)
          */
         async start() {
-          const { helper } = this.facets;
-          helper.rescheduleLiquidationWakeups();
-          await updateShortfallReporter();
+          const { helper, machine } = this.facets;
+
+          await helper.resetWakeupsForNextAuction();
+          updateShortfallReporter().catch(err =>
+            console.error(
+              '🛠️ updateShortfallReporter failed during start(); repair by updating governance',
+              err,
+            ),
+          );
+          // independent of the other one which can be canceled
+          const rescheduleWaker = machine.makeReschedulerWaker();
+          void watchForGovernanceChange(auctioneer, timer, rescheduleWaker);
         },
       },
     },
@@ -550,17 +562,15 @@ export const prepareVaultDirector = (
 harden(prepareVaultDirector);
 
 /**
- * Prepare the VaultDirector kind, get or make the singleton, and call .start() to kick off processes.
+ * Prepare the VaultDirector kind, get or make the singleton
  *
  * @type {(...pvdArgs: Parameters<typeof prepareVaultDirector>) => ReturnType<ReturnType<typeof prepareVaultDirector>>}
  */
-export const provideAndStartDirector = (...args) => {
+export const provideDirector = (...args) => {
   const makeVaultDirector = prepareVaultDirector(...args);
 
   const [baggage] = args;
 
-  const director = provide(baggage, 'director', makeVaultDirector);
-  director.helper.start();
-  return director;
+  return provide(baggage, 'director', makeVaultDirector);
 };
-harden(provideAndStartDirector);
+harden(provideDirector);

package/src/vaultFactory/vaultFactory.js

@@ -20,13 +20,16 @@ import '@agoric/zoe/src/contracts/exported.js';
 import { CONTRACT_ELECTORATE } from '@agoric/governance';
 import { makeParamManagerFromTerms } from '@agoric/governance/src/contractGovernance/typedParamManager.js';
 import { validateElectorate } from '@agoric/governance/src/contractHelper.js';
-import { assertAllDefined, makeTracer } from '@agoric/internal';
+import { makeTracer, StorageNodeShape } from '@agoric/internal';
 import { makeStoredSubscription, makeSubscriptionKit } from '@agoric/notifier';
+import { M } from '@agoric/store';
 import { provideAll } from '@agoric/zoe/src/contractSupport/durability.js';
 import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport/recorder.js';
 import { E } from '@endo/eventual-send';
+import { FeeMintAccessShape } from '@agoric/zoe/src/typeGuards.js';
+import { InvitationShape } from '../auction/params.js';
 import { SHORTFALL_INVITATION_KEY, vaultDirectorParamTypes } from './params.js';
-import { provideAndStartDirector } from './vaultDirector.js';
+import { provideDirector } from './vaultDirector.js';
 
 const trace = makeTracer('VF', false);
 
@@ -39,6 +42,20 @@ const trace = makeTracer('VF', false);
  * }>} VaultFactoryZCF
  */
 
+export const privateArgsShape = M.splitRecord(
+  harden({
+    marshaller: M.remotable('Marshaller'),
+    storageNode: StorageNodeShape,
+  }),
+  harden({
+    // only necessary on first invocation, not subsequent
+    feeMintAccess: FeeMintAccessShape,
+    initialPoserInvitation: InvitationShape,
+    initialShortfallInvitation: InvitationShape,
+  }),
+);
+harden(privateArgsShape);
+
 /**
  * @param {VaultFactoryZCF} zcf
  * @param {{
@@ -53,19 +70,11 @@ const trace = makeTracer('VF', false);
 export const prepare = async (zcf, privateArgs, baggage) => {
   trace('prepare start', privateArgs, [...baggage.keys()]);
   const {
-    feeMintAccess,
     initialPoserInvitation,
     initialShortfallInvitation,
     marshaller,
     storageNode,
   } = privateArgs;
-  assertAllDefined({
-    feeMintAccess,
-    initialPoserInvitation,
-    initialShortfallInvitation,
-    marshaller,
-    storageNode,
-  });
 
   trace('awaiting debtMint');
   const { debtMint } = await provideAll(baggage, {
@@ -107,7 +116,7 @@ export const prepare = async (zcf, privateArgs, baggage) => {
     vaultDirectorParamTypes,
   );
 
-  const director = provideAndStartDirector(
+  const director = provideDirector(
     baggage,
     zcf,
     vaultDirectorParamManager,
@@ -121,6 +130,12 @@ export const prepare = async (zcf, privateArgs, baggage) => {
     makeERecorderKit,
   );
 
+  // cannot await because it would make remote calls during vat restart
+  director.helper.start().catch(err => {
+    console.error('💀 vaultDirector failed to start:', err);
+    zcf.shutdownWithFailure(err);
+  });
+
   // validate async to wait for params to be finished
   // UNTIL https://github.com/Agoric/agoric-sdk/issues/4343
   void validateElectorate(zcf, vaultDirectorParamManager);