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

package/src/auction/scheduler.js

@@ -2,14 +2,22 @@ import { E } from '@endo/eventual-send';
 import { TimeMath } from '@agoric/time';
 import { Far } from '@endo/marshal';
 import { makeTracer } from '@agoric/internal';
+import { observeIteration, subscribeEach } from '@agoric/notifier';
 
-import { AuctionState } from './util.js';
-import { nextDescendingStepTime, computeRoundTiming } from './scheduleMath.js';
+import { AuctionState, makeCancelTokenMaker } from './util.js';
+import {
+  computeRoundTiming,
+  nextDescendingStepTime,
+  timeVsSchedule,
+} from './scheduleMath.js';
 
-const { Fail, quote: q } = assert;
+const { details: X, Fail, quote: q } = assert;
 
 const trace = makeTracer('SCHED', false);
 
+// If the startAuction wakeup is no more than 5 minutes late, go ahead with it.
+const MAX_LATE_TICK = 300n;
+
 /**
  * @file The scheduler is presumed to be quiescent between auction rounds. Each
  * Auction round consists of a sequence of steps with decreasing prices. There
@@ -28,10 +36,8 @@ const trace = makeTracer('SCHED', false);
  * progress. It would take additional work on the manual timer to test this
  * thoroughly.
  */
-const makeCancelToken = () => {
-  let tokenCount = 1;
-  return Far(`cancelToken${(tokenCount += 1)}`, {});
-};
+
+const makeCancelToken = makeCancelTokenMaker('scheduler');
 
 /**
  * @typedef {object} AuctionDriver
@@ -44,19 +50,29 @@ const makeCancelToken = () => {
 /**
  * @typedef {object} ScheduleNotification
  *
- * @property {Timestamp | undefined} activeStartTime start time of current
+ * @property {Timestamp | null} activeStartTime start time of current
  *    auction if auction is active
- * @property {Timestamp} nextStartTime start time of next auction
- * @property {Timestamp} nextDescendingStepTime when the next descending step
+ * @property {Timestamp | null} nextStartTime start time of next auction
+ * @property {Timestamp | null} nextDescendingStepTime when the next descending step
  *    will take place
  */
 
+const safelyComputeRoundTiming = (params, baseTime) => {
+  try {
+    return computeRoundTiming(params, baseTime);
+  } catch (e) {
+    console.error('🚨 No Next Auction', e);
+    return null;
+  }
+};
+
 /**
  * @param {AuctionDriver} auctionDriver
  * @param {import('@agoric/time/src/types').TimerService} timer
- * @param {Awaited<import('./params.js').AuctionParamManaager>} params
+ * @param {Awaited<import('./params.js').AuctionParamManager>} params
  * @param {import('@agoric/time/src/types').TimerBrand} timerBrand
  * @param {import('@agoric/zoe/src/contractSupport/recorder.js').Recorder<ScheduleNotification>} scheduleRecorder
+ * @param {StoredSubscription<GovernanceSubscriptionState>} paramUpdateSubscription
  */
 export const makeScheduler = async (
   auctionDriver,
@@ -64,21 +80,22 @@ export const makeScheduler = async (
   params,
   timerBrand,
   scheduleRecorder,
+  paramUpdateSubscription,
 ) => {
   /**
    * live version is defined when an auction is active.
    *
-   * @type {Schedule | undefined}
+   * @type {Schedule | null}
    */
-  let liveSchedule;
+  let liveSchedule = null;
 
-  /** @returns {Promise<{ now: Timestamp, nextSchedule: Schedule }>} */
+  /** @returns {Promise<{ now: Timestamp, nextSchedule: Schedule | null }>} */
   const initializeNextSchedule = async () => {
     return E.when(
       // XXX manualTimer returns a bigint, not a timeRecord.
       E(timer).getCurrentTimestamp(),
       now => {
-        const nextSchedule = computeRoundTiming(
+        const nextSchedule = safelyComputeRoundTiming(
           params,
           TimeMath.coerceTimestampRecord(now, timerBrand),
         );
@@ -103,66 +120,105 @@ export const makeScheduler = async (
    */
   const publishSchedule = () => {
     const sched = harden({
-      activeStartTime: liveSchedule?.startTime,
-      nextStartTime: nextSchedule?.startTime,
+      activeStartTime: liveSchedule?.startTime || null,
+      nextStartTime: nextSchedule?.startTime || null,
       nextDescendingStepTime: nextDescendingStepTime(
         liveSchedule,
         nextSchedule,
         now,
       ),
     });
-    scheduleRecorder.write(sched);
+    return scheduleRecorder.write(sched);
   };
 
   /**
-   * @param {Schedule | undefined} schedule
+   * @param {Schedule | null} schedule
+   * @returns {Promise<void>}
    */
-  const clockTick = schedule => {
+  const clockTick = async schedule => {
     trace('clockTick', schedule?.startTime, now);
     if (!schedule) {
       return;
     }
 
-    if (
-      TimeMath.compareAbs(now, schedule.startTime) >= 0 &&
-      TimeMath.compareAbs(now, schedule.endTime) <= 0
-    ) {
-      if (auctionState !== AuctionState.ACTIVE) {
-        auctionState = AuctionState.ACTIVE;
-        auctionDriver.startRound();
-      } else {
-        auctionDriver.reducePriceAndTrade();
-      }
-    }
-
-    if (TimeMath.compareAbs(now, schedule.endTime) >= 0) {
+    /** @type {() => void} */
+    const finishAuctionRound = () => {
       auctionState = AuctionState.WAITING;
-
       auctionDriver.finalize();
 
-      if (!nextSchedule) throw Fail`nextSchedule not defined`;
-
-      // only recalculate the next schedule at this point if the lock time has
-      // not been reached.
-      const nextLock = nextSchedule.lockTime;
-      if (nextLock && TimeMath.compareAbs(now, nextLock) < 0) {
-        const afterNow = TimeMath.addAbsRel(
-          now,
-          TimeMath.coerceRelativeTimeRecord(1n, timerBrand),
+      if (nextSchedule) {
+        // only recalculate the next schedule at this point if the lock time has
+        // not been reached.
+        const nextLock = nextSchedule.lockTime;
+        if (nextLock && TimeMath.compareAbs(now, nextLock) < 0) {
+          const afterNow = TimeMath.addAbsRel(
+            now,
+            TimeMath.coerceRelativeTimeRecord(1n, timerBrand),
+          );
+          nextSchedule = safelyComputeRoundTiming(params, afterNow);
+        }
+      } else {
+        console.error(
+          '🛠️ finishAuctionRound without scheduling the next; repair with new auctioneer params',
         );
-        nextSchedule = computeRoundTiming(params, afterNow);
       }
-      liveSchedule = undefined;
 
+      liveSchedule = null;
+
+      // Async because a remote call. In rare event of failure, wakeup is robust.
       void E(timer).cancel(stepCancelToken);
+    };
+
+    const advanceRound = () => {
+      if (auctionState === AuctionState.ACTIVE) {
+        auctionDriver.reducePriceAndTrade();
+      } else {
+        auctionState = AuctionState.ACTIVE;
+        try {
+          auctionDriver.startRound();
+          // This has been observed to fail because prices hadn't been locked.
+          // This may be an issue about timing during chain start-up.
+        } catch (e) {
+          console.error(
+            assert.error(
+              'Unable to start auction cleanly. skipping this auction round.',
+            ),
+          );
+          finishAuctionRound();
+
+          return false;
+        }
+      }
+      return true;
+    };
+
+    switch (timeVsSchedule(now, schedule)) {
+      case 'before':
+        break;
+      case 'during':
+        advanceRound();
+        break;
+      case 'endExactly':
+        if (advanceRound()) {
+          finishAuctionRound();
+        }
+        break;
+      case 'after':
+        await finishAuctionRound();
+        break;
+      default:
+        Fail`invalid case`;
     }
 
-    publishSchedule();
+    void publishSchedule();
   };
 
-  // schedule the wakeups for the steps of this round
-  const scheduleSteps = () => {
-    if (!liveSchedule) throw Fail`liveSchedule not defined`;
+  // set wakeups for the steps of this round
+  const queueLiveSchedule = () => {
+    if (!liveSchedule) {
+      console.error('🚨 queueLiveSchedule called with no liveSchedule');
+      return;
+    }
 
     const { startTime } = liveSchedule;
     trace('START ', startTime);
@@ -172,7 +228,7 @@ export const makeScheduler = async (
         ? TimeMath.subtractAbsAbs(startTime, now)
         : TimeMath.subtractAbsAbs(startTime, startTime);
 
-    trace('repeating', now, delayFromNow, startTime);
+    trace('queueLiveSchedule repeating', now, delayFromNow, startTime);
 
     void E(timer).repeatAfter(
       delayFromNow,
@@ -181,7 +237,7 @@ export const makeScheduler = async (
         wake(time) {
           setTimeMonotonically(time);
           trace('wake step', now);
-          clockTick(liveSchedule);
+          void clockTick(liveSchedule);
         },
       }),
       stepCancelToken,
@@ -197,11 +253,11 @@ export const makeScheduler = async (
         wake(time) {
           setTimeMonotonically(time);
           // eslint-disable-next-line no-use-before-define
-          void startAuction();
+          return startAuction();
         },
       }),
     );
-    publishSchedule();
+    void publishSchedule();
   };
 
   // schedule a wakeup to lock prices
@@ -218,43 +274,99 @@ export const makeScheduler = async (
     );
   };
 
+  const relativeTime = t => TimeMath.coerceRelativeTimeRecord(t, timerBrand);
+
   const startAuction = async () => {
     !liveSchedule || Fail`can't start an auction round while one is active`;
 
-    assert(nextSchedule);
+    if (!nextSchedule) {
+      console.error(
+        assert.error(X`tried to start auction when none is scheduled`),
+      );
+      return;
+    }
+
     // The clock tick may have arrived too late to trigger the next scheduled
     // round, for example because of a chain halt.  When this happens the oracle
     // quote may out of date and so must be ignored. Recover by returning
-    // deposits and scheduling the next round.
-    if (TimeMath.compareAbs(now, nextSchedule.startTime) > 0) {
-      console.warn(
-        `Auction time jumped to ${q(now)} before next scheduled start ${q(
-          nextSchedule.startTime,
-        )}. Skipping that round.`,
-      );
-      nextSchedule = computeRoundTiming(params, now);
+    // deposits and scheduling the next round. If it's only a little late,
+    // continue with auction, just starting late.
+    const nominalStart = TimeMath.subtractAbsRel(
+      nextSchedule.startTime,
+      nextSchedule.startDelay,
+    );
+    if (TimeMath.compareAbs(now, nominalStart) > 0) {
+      const late = TimeMath.subtractAbsAbs(now, nominalStart);
+      const maxLate = relativeTime(MAX_LATE_TICK);
+
+      if (TimeMath.compareRel(late, maxLate) > 0) {
+        console.warn(
+          `Auction time jumped to ${q(now)} before next scheduled start ${q(
+            nextSchedule.startTime,
+          )}. Skipping that round.`,
+        );
+        nextSchedule = safelyComputeRoundTiming(params, now);
+      } else {
+        console.warn(`Auction started late by ${q(late)}. Starting ${q(now)}`);
+      }
     }
-    liveSchedule = nextSchedule;
 
-    const after = TimeMath.addAbsRel(
-      liveSchedule.endTime,
-      TimeMath.coerceRelativeTimeRecord(1n, timerBrand),
+    if (!nextSchedule) {
+      // nothing new to schedule
+      return;
+    }
+    // activate the nextSchedule as the live one
+    // (read here and in function calls below)
+    liveSchedule = nextSchedule;
+    nextSchedule = safelyComputeRoundTiming(
+      params,
+      TimeMath.addAbsRel(liveSchedule.endTime, relativeTime(1n)),
     );
-    nextSchedule = computeRoundTiming(params, after);
 
-    scheduleSteps();
-    scheduleNextRound(
-      TimeMath.subtractAbsRel(nextSchedule.startTime, nextSchedule.startDelay),
-    );
-    schedulePriceLock(nextSchedule.lockTime);
+    queueLiveSchedule();
+    if (nextSchedule) {
+      scheduleNextRound(
+        TimeMath.subtractAbsRel(
+          nextSchedule.startTime,
+          nextSchedule.startDelay,
+        ),
+      );
+      schedulePriceLock(nextSchedule.lockTime);
+    } else {
+      console.warn(
+        'no nextSchedule so cannot schedule next round or price lock',
+      );
+    }
   };
 
-  const firstStart = TimeMath.subtractAbsRel(
-    nextSchedule.startTime,
-    nextSchedule.startDelay,
+  // initial setting:  firstStart is startDelay before next's startTime
+  const startSchedulingFromScratch = () => {
+    trace('startSchedulingFromScratch');
+    if (nextSchedule) {
+      const firstStart = TimeMath.subtractAbsRel(
+        nextSchedule.startTime,
+        nextSchedule.startDelay,
+      );
+      scheduleNextRound(firstStart);
+      schedulePriceLock(nextSchedule.lockTime);
+    }
+  };
+  startSchedulingFromScratch();
+
+  // when auction parameters change, schedule a next auction if one isn't
+  // already scheduled
+  void observeIteration(
+    subscribeEach(paramUpdateSubscription),
+    harden({
+      async updateState(_newState) {
+        trace('received param update');
+        if (!nextSchedule) {
+          ({ nextSchedule } = await initializeNextSchedule());
+          startSchedulingFromScratch();
+        }
+      },
+    }),
   );
-  scheduleNextRound(firstStart);
-  schedulePriceLock(nextSchedule.lockTime);
 
   return Far('scheduler', {
     getSchedule: () =>
@@ -279,6 +391,6 @@ export const makeScheduler = async (
 
 /**
  * @typedef {object} FullSchedule
- * @property {Schedule | undefined} nextAuctionSchedule
- * @property {Schedule | undefined} liveAuctionSchedule
+ * @property {Schedule | null} nextAuctionSchedule
+ * @property {Schedule | null} liveAuctionSchedule
  */

package/src/auction/util.js

@@ -5,6 +5,7 @@ import {
   multiplyRatios,
   ratioGTE,
 } from '@agoric/zoe/src/contractSupport/index.js';
+import { Far } from '@endo/marshal';
 
 /**
  * Constants for Auction State.
@@ -46,3 +47,9 @@ export const priceFrom = quote =>
     quote.quoteAmount.value[0].amountOut,
     quote.quoteAmount.value[0].amountIn,
   );
+
+export const makeCancelTokenMaker = name => {
+  let tokenCount = 1;
+
+  return () => Far(`cancelToken-${name}-${(tokenCount += 1)}`, {});
+};

package/src/clientSupport.js

@@ -174,7 +174,7 @@ const makePsmProposal = (brands, opts, fee = 0, anchor = 'AUSD') => {
  * @param {Instance} instance
  * @param {Record<string, Brand>} brands
  * @param {{ offerId: number, feePct?: number } &
- *         ({ wantMinted: number | undefined, giveMinted: number | undefined })} opts
+ *         ({ wantMinted: number | undefined, giveMinted: number | undefined, pair: [string, string] })} opts
  * @returns {import('@agoric/smart-wallet/src/offers.js').OfferSpec}
  */
 const makePsmSwapOffer = (instance, brands, opts) => {
@@ -185,7 +185,6 @@ const makePsmSwapOffer = (instance, brands, opts) => {
     brands,
     opts,
     opts.feePct ? opts.feePct / 100 : undefined,
-    // @ts-expect-error please update types. Not sure where pair goees.
     opts.pair[1],
   );
 

package/src/price/fluxAggregatorContract.js

@@ -6,8 +6,9 @@ import {
   prepareIssuerKit,
 } from '@agoric/ertp';
 import { handleParamGovernance } from '@agoric/governance';
-import { assertAllDefined, makeTracer } from '@agoric/internal';
+import { makeTracer, StorageNodeShape } from '@agoric/internal';
 import { prepareDurablePublishKit } from '@agoric/notifier';
+import { M } from '@agoric/store';
 import { provideAll } from '@agoric/zoe/src/contractSupport/durability.js';
 import { prepareRecorder } from '@agoric/zoe/src/contractSupport/recorder.js';
 import { E } from '@endo/eventual-send';
@@ -20,6 +21,23 @@ const trace = makeTracer('FluxAgg');
  * @typedef {import('@agoric/time/src/types').TimerService} TimerService
  */
 
+export const privateArgsShape = M.splitRecord(
+  harden({
+    storageNode: StorageNodeShape,
+    marshaller: M.eref(M.remotable('marshaller')),
+    namesByAddressAdmin: M.any(),
+  }),
+  harden({
+    // always optional. XXX some code is including the key, set to null
+    highPrioritySendersManager: M.or(
+      M.remotable('prioritySenders manager'),
+      M.null(),
+    ),
+    // only necessary on first invocation, not subsequent
+    initialPoserInvitation: M.remotable('Invitation'),
+  }),
+);
+
 /**
  * PriceAuthority for their median. Unlike the simpler `priceAggregator.js`, this approximates
  * the *Node Operator Aggregation* logic of [Chainlink price
@@ -33,9 +51,9 @@ const trace = makeTracer('FluxAgg');
  * unitAmountIn?: Amount<'nat'>,
  * }>} zcf
  * @param {{
- * highPrioritySendersManager: import('@agoric/internal/src/priority-senders.js').PrioritySendersManager,
+ * highPrioritySendersManager?: import('@agoric/internal/src/priority-senders.js').PrioritySendersManager,
  * initialPoserInvitation: Invitation,
- * marshaller: Marshaller,
+ * marshaller: ERef<Marshaller>,
  * namesByAddressAdmin: ERef<import('@agoric/vats').NameAdmin>,
  * storageNode: StorageNode,
  * }} privateArgs
@@ -57,7 +75,6 @@ export const prepare = async (zcf, privateArgs, baggage) => {
     namesByAddressAdmin,
     storageNode,
   } = privateArgs;
-  assertAllDefined({ initialPoserInvitation, marshaller, storageNode });
 
   const { description, timer } = zcf.getTerms();
 
@@ -114,7 +131,10 @@ export const prepare = async (zcf, privateArgs, baggage) => {
       addr,
       [invitation],
     );
-    await highPrioritySendersManager.add(description, addr);
+    if (highPrioritySendersManager) {
+      // eslint-disable-next-line @jessie.js/no-nested-await -- after another await
+      await E(highPrioritySendersManager).add(description, addr);
+    }
     return `added ${addr}`;
   };
 
@@ -126,7 +146,10 @@ export const prepare = async (zcf, privateArgs, baggage) => {
   const removeOracle = async addr => {
     trace('removeOracle', addr);
     await E(faKit.creator).removeOracle(addr);
-    highPrioritySendersManager.remove(description, addr);
+    if (highPrioritySendersManager) {
+      // eslint-disable-next-line @jessie.js/no-nested-await -- after another await
+      await E(highPrioritySendersManager).remove(description, addr);
+    }
     return `removed ${addr}`;
   };
 

package/src/proposals/addAssetToVault.js

@@ -54,15 +54,7 @@ export const publishInterchainAssetFromBoardId = async (
  */
 export const publishInterchainAssetFromBank = async (
   {
-    consume: {
-      bankManager,
-      agoricNamesAdmin,
-      bankMints,
-      vBankKits,
-      reserveKit,
-      startUpgradable: startUpgradableP,
-    },
-    produce: { bankMints: produceBankMints, vBankKits: produceVBankKits },
+    consume: { bankManager, agoricNamesAdmin, reserveKit, startUpgradable },
     installation: {
       consume: { mintHolder },
     },
@@ -88,16 +80,11 @@ export const publishInterchainAssetFromBank = async (
     },
   };
 
-  const startUpgradable = await startUpgradableP;
-  produceVBankKits.resolve([]);
-  const { creatorFacet: mint, publicFacet: issuer } = await startUpgradable({
+  const { creatorFacet: mint, publicFacet: issuer } = await E(startUpgradable)({
     installation: mintHolder,
     label: keyword,
     privateArgs: undefined,
     terms,
-    produceResults: {
-      resolve: kit => Promise.resolve(vBankKits).then(kits => kits.push(kit)),
-    },
   });
 
   const brand = await E(issuer).getBrand();
@@ -105,13 +92,7 @@ export const publishInterchainAssetFromBank = async (
 
   await E(E.get(reserveKit).creatorFacet).addIssuer(issuer, keyword);
 
-  // Create the mint list if it doesn't exist and wasn't already rejected.
-  produceBankMints.resolve([]);
   await Promise.all([
-    Promise.resolve(bankMints).then(
-      mints => mints.push(mint),
-      () => {}, // If the bankMints list was rejected, ignore the error.
-    ),
     E(E(agoricNamesAdmin).lookupAdmin('issuer')).update(keyword, issuer),
     E(E(agoricNamesAdmin).lookupAdmin('brand')).update(keyword, brand),
     E(bankManager).addAsset(denom, keyword, proposedName, kit),
@@ -128,12 +109,10 @@ export const registerScaledPriceAuthority = async (
   {
     consume: {
       agoricNamesAdmin,
-      startUpgradable: startUpgradableP,
+      startUpgradable,
       priceAuthorityAdmin,
       priceAuthority,
-      scaledPriceAuthorityKits,
     },
-    produce: { scaledPriceAuthorityKits: produceScaledPriceAuthorityKits },
   },
   { options: { interchainAssetOptions } },
 ) => {
@@ -209,17 +188,10 @@ export const registerScaledPriceAuthority = async (
     }),
   );
 
-  const startUpgradable = await startUpgradableP;
-  produceScaledPriceAuthorityKits.resolve([]);
-  const spaKit = await startUpgradable({
+  const spaKit = await E(startUpgradable)({
     installation: scaledPriceAuthority,
     label: `scaledPriceAuthority-${keyword}`,
     terms,
-    produceResults: {
-      resolve: kit =>
-        Promise.resolve(scaledPriceAuthorityKits).then(kits => kits.push(kit)),
-    },
-    privateArgs: undefined,
   });
 
   await E(priceAuthorityAdmin).registerPriceAuthority(
@@ -238,7 +210,7 @@ export const registerScaledPriceAuthority = async (
  * @param {object} config
  * @param {object} config.options
  * @param {InterchainAssetOptions} config.options.interchainAssetOptions
- * @param {bigint} config.options.debtLimitValue
+ * @param {bigint | number | string} config.options.debtLimitValue
  * @param {bigint} config.options.interestRateValue
  */
 export const addAssetToVault = async (
@@ -270,7 +242,7 @@ export const addAssetToVault = async (
   const stable = await stableP;
   const vaultFactoryCreator = E.get(vaultFactoryKit).creatorFacet;
   await E(vaultFactoryCreator).addVaultType(interchainIssuer, oracleBrand, {
-    debtLimit: AmountMath.make(stable, debtLimitValue),
+    debtLimit: AmountMath.make(stable, BigInt(debtLimitValue)),
     interestRate: makeRatio(interestRateValue, stable),
     // The rest of these we use safe defaults.
     // In production they will be governed by the Econ Committee.

package/src/proposals/committee-proposal.js

@@ -15,11 +15,7 @@ const EC_HIGH_PRIORITY_SENDERS_NAMESPACE = 'economicCommittee';
  */
 export const inviteCommitteeMembers = async (
   {
-    consume: {
-      namesByAddressAdmin,
-      economicCommitteeCreatorFacet,
-      highPrioritySendersManager,
-    },
+    consume: { namesByAddressAdmin, economicCommitteeCreatorFacet, ...consume },
   },
   { options: { voterAddresses } },
 ) => {
@@ -28,6 +24,8 @@ export const inviteCommitteeMembers = async (
   ).getVoterInvitations();
   assert.equal(invitations.length, values(voterAddresses).length);
 
+  const highPrioritySendersManager = await consume.highPrioritySendersManager;
+
   /**
    * @param {[string, Promise<Invitation>][]} addrInvitations
    */
@@ -40,10 +38,12 @@ export const inviteCommitteeMembers = async (
           addr,
           [invitationP],
         );
-        await E(highPrioritySendersManager)?.add(
-          EC_HIGH_PRIORITY_SENDERS_NAMESPACE,
-          addr,
-        );
+        if (highPrioritySendersManager) {
+          await E(highPrioritySendersManager).add(
+            EC_HIGH_PRIORITY_SENDERS_NAMESPACE,
+            addr,
+          );
+        }
       }),
     );
   };