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

package/src/auction/params.js

@@ -6,14 +6,17 @@ import {
 import { TimeMath, RelativeTimeRecordShape } from '@agoric/time';
 import { M } from '@agoric/store';
 
-/** @typedef {import('@agoric/governance/src/contractGovernance/typedParamManager.js').AsyncSpecTuple} AsyncSpecTuple */
-/** @typedef {import('@agoric/governance/src/contractGovernance/typedParamManager.js').SyncSpecTuple} SyncSpecTuple */
+/**
+ * @import {AsyncSpecTuple} from '@agoric/governance/src/contractGovernance/typedParamManager.js';
+ * @import {SyncSpecTuple} from '@agoric/governance/src/contractGovernance/typedParamManager.js';
+ * @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js';
+ */
 
 // TODO duplicated with zoe/src/TypeGuards.js
 export const InvitationShape = M.remotable('Invitation');
 
 /**
- * In seconds, how often to start an auction.  The auction will start at
+ * In seconds, how often to start an auction. The auction will start at
  * AUCTION_START_DELAY seconds after a multiple of START_FREQUENCY, with the
  * price at STARTING_RATE_BP. Every CLOCK_STEP, the price will be reduced by
  * DISCOUNT_STEP_BP, as long as the rate is at or above LOWEST_RATE_BP, or until
@@ -70,12 +73,10 @@ export const auctioneerParamTypes = harden({
  * @property {bigint} DiscountStep
  * @property {RelativeTime} AuctionStartDelay
  * @property {RelativeTime} PriceLockPeriod
- * @property {import('@agoric/time/src/types').TimerBrand} TimerBrand
+ * @property {import('@agoric/time').TimerBrand} TimerBrand
  */
 
-/**
- * @param {AuctionParams} initial
- */
+/** @param {AuctionParams} initial */
 export const makeAuctioneerParams = ({
   ElectorateInvitationAmount,
   StartFrequency,
@@ -146,10 +147,11 @@ export const makeAuctioneerParamManager = (publisherKit, zcf, initial) => {
   );
 };
 harden(makeAuctioneerParamManager);
+/** @typedef {ReturnType<typeof makeAuctioneerParams>} AuctionParamRecord */
 
 /**
- * @param {{storageNode: ERef<StorageNode>, marshaller: ERef<Marshaller>}} caps
- * @param {ERef<Timer>} timer
+ * @param {{ storageNode: ERef<StorageNode>; marshaller: ERef<Marshaller> }} caps
+ * @param {ERef<import('@agoric/time').TimerService>} timer
  * @param {ERef<PriceAuthority>} priceAuthority
  * @param {ERef<AssetReservePublicFacet>} reservePublicFacet
  * @param {AuctionParams} params

package/src/auction/scheduleMath.d.ts

@@ -0,0 +1,5 @@
+export function computeRoundTiming(params: Awaited<import("./params.js").AuctionParamManager>, baseTime: TimestampRecord): import("./scheduler.js").Schedule;
+export function nextDescendingStepTime(liveSchedule: import("./scheduler.js").Schedule | null, nextSchedule: import("./scheduler.js").Schedule | null, now: Timestamp): Timestamp | null;
+export function timeVsSchedule(time: Timestamp, schedule: import("./scheduler.js").Schedule): "before" | "during" | "endExactly" | "after";
+import type { TimestampRecord } from '@agoric/time';
+//# sourceMappingURL=scheduleMath.d.ts.map

package/src/auction/scheduleMath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduleMath.d.ts","sourceRoot":"","sources":["scheduleMath.js"],"names":[],"mappings":"AA0CO,2CAJI,OAAO,CAAC,OAAO,aAAa,EAAE,mBAAmB,CAAC,YAClD,eAAe,GACb,OAAO,gBAAgB,EAAE,QAAQ,CAqE7C;AAcM,qDALI,OAAO,gBAAgB,EAAE,QAAQ,GAAG,IAAI,gBACxC,OAAO,gBAAgB,EAAE,QAAQ,GAAG,IAAI,OACxC,SAAS,GACP,SAAS,GAAG,IAAI,CAuB5B;AAQM,qCAJI,SAAS,YACT,OAAO,gBAAgB,EAAE,QAAQ,GAC/B,QAAQ,GAAG,QAAQ,GAAG,YAAY,GAAG,OAAO,CAiBxD;qCAhKkC,cAAc"}

package/src/auction/scheduleMath.js

@@ -1,11 +1,13 @@
 // @jessie-check
 
+import { Fail } from '@endo/errors';
 import { TimeMath } from '@agoric/time';
 import { natSafeMath } from '@agoric/zoe/src/contractSupport/index.js';
 import { assertAllDefined, makeTracer } from '@agoric/internal';
 
+/** @import {TimestampRecord} from '@agoric/time'; */
+
 const { subtract, multiply, floorDivide } = natSafeMath;
-const { Fail } = assert;
 
 const trace = makeTracer('SMath', true);
 
@@ -18,23 +20,24 @@ const subtract1 = relTime =>
 /**
  * The length of the auction has to be inferred from the governed params.
  *
- * 1. The auction starts by offering collateral at a `StartingRate` (e.g., 105%)
- *    of the market price at auction start, and continues until it reaches
- *    (or would exceed on its next step) LowestRate (e.g., 65%)
+ * 1. The auction starts by offering collateral at a `StartingRate` (e.g., 105%) of
+ *    the market price at auction start, and continues until it reaches (or
+ *    would exceed on its next step) LowestRate (e.g., 65%)
  * 2. The offer price changes every `ClockStep` seconds
- * 3. The offer price changes by `DiscountStep` amount (e.g., 5%) each step So
- *    it must run however many `ClockSteps` are required to get from
- *    `StartingRate` to `LowestRate` changing by `DiscountStep` each time.
+ * 3. The offer price changes by `DiscountStep` amount (e.g., 5%) each step So it
+ *    must run however many `ClockSteps` are required to get from `StartingRate`
+ *    to `LowestRate` changing by `DiscountStep` each time.
  *
- * Therefore, the duration is `(StartingRate - LowestRate) / DiscountStep * ClockStep`.
+ * Therefore, the duration is `(StartingRate - LowestRate) / DiscountStep *
+ * ClockStep`.
  *
- * Note that this is what's *scheduled*. More than one auction can be running
+ * Note that this is what's _scheduled_. More than one auction can be running
  * simultaneously, and some conditions can cause some of the auctions to stop
  * selling early (e.g. reaching their target debt to raise or selling all of
  * their collateral).
  *
  * @param {Awaited<import('./params.js').AuctionParamManager>} params
- * @param {Timestamp} baseTime
+ * @param {TimestampRecord} baseTime
  * @returns {import('./scheduler.js').Schedule}
  */
 export const computeRoundTiming = (params, baseTime) => {
@@ -82,7 +85,7 @@ export const computeRoundTiming = (params, baseTime) => {
   // computed start is `startDelay + baseTime + freq - (baseTime mod freq)`.
   // That is, if there are hourly starts, we add an hour to the time, and
   // subtract baseTime mod freq. Then we add the delay.
-  /** @type {import('@agoric/time/src/types').TimestampRecord} */
+  /** @type {TimestampRecord} */
   const startTime = TimeMath.addAbsRel(
     TimeMath.addAbsRel(
       baseTime,
@@ -108,10 +111,10 @@ export const computeRoundTiming = (params, baseTime) => {
 harden(computeRoundTiming);
 
 /**
- * Calculate when the next descending step will start. If we're between
- * auctions (i.e. liveSchedule is undefined), or the last step of the current
- * auction has started, then it'll be nextSchedule.startTime. Otherwise, it's
- * the start of the step following the current step.
+ * Calculate when the next descending step will start. If we're between auctions
+ * (i.e. liveSchedule is undefined), or the last step of the current auction has
+ * started, then it'll be nextSchedule.startTime. Otherwise, it's the start of
+ * the step following the current step.
  *
  * @param {import('./scheduler.js').Schedule | null} liveSchedule
  * @param {import('./scheduler.js').Schedule | null} nextSchedule
@@ -143,7 +146,6 @@ export const nextDescendingStepTime = (liveSchedule, nextSchedule, now) => {
 harden(nextDescendingStepTime);
 
 /**
- *
  * @param {Timestamp} time
  * @param {import('./scheduler.js').Schedule} schedule
  * @returns {'before' | 'during' | 'endExactly' | 'after'}

package/src/auction/scheduler.d.ts

@@ -0,0 +1,50 @@
+export function makeScheduler(auctionDriver: AuctionDriver, timer: import("@agoric/time").TimerService, params: Awaited<import("./params.js").AuctionParamManager>, timerBrand: import("@agoric/time").TimerBrand, scheduleRecorder: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<ScheduleNotification>, paramUpdateSubscription: StoredSubscription<GovernanceSubscriptionState>): Promise<{
+    getSchedule: () => {
+        liveAuctionSchedule: Schedule | null;
+        nextAuctionSchedule: Schedule | null;
+    };
+    getAuctionState: () => AuctionState;
+} & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+    getSchedule: () => {
+        liveAuctionSchedule: Schedule | null;
+        nextAuctionSchedule: Schedule | null;
+    };
+    getAuctionState: () => AuctionState;
+}>>;
+export type AuctionDriver = {
+    reducePriceAndTrade: () => void;
+    finalize: () => void;
+    startRound: () => void;
+    capturePrices: () => void;
+};
+export type ScheduleNotification = {
+    /**
+     * start time of current auction if
+     * auction is active
+     */
+    activeStartTime: Timestamp | null;
+    /**
+     * start time of next auction
+     */
+    nextStartTime: Timestamp | null;
+    /**
+     * when the next descending
+     * step will take place
+     */
+    nextDescendingStepTime: Timestamp | null;
+};
+export type Schedule = {
+    startTime: import("@agoric/time").TimestampRecord;
+    endTime: import("@agoric/time").TimestampRecord;
+    steps: NatValue;
+    endRate: NatValue;
+    startDelay: RelativeTime;
+    clockStep: RelativeTime;
+    lockTime?: Timestamp | undefined;
+};
+export type FullSchedule = {
+    nextAuctionSchedule: Schedule | null;
+    liveAuctionSchedule: Schedule | null;
+};
+import { AuctionState } from './util.js';
+//# sourceMappingURL=scheduler.d.ts.map

package/src/auction/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["scheduler.js"],"names":[],"mappings":"AA8EO,6CAPI,aAAa,SACb,OAAO,cAAc,EAAE,YAAY,UACnC,OAAO,CAAC,OAAO,aAAa,EAAE,mBAAmB,CAAC,cAClD,OAAO,cAAc,EAAE,UAAU,oBACjC,OAAO,6CAA6C,EAAE,QAAQ,CAAC,oBAAoB,CAAC,2BACpF,kBAAkB,CAAC,2BAA2B,CAAC;;;;;;;;;;;;IA0RzD;;yBA3Ta,MAAM,IAAI;cACV,MAAM,IAAI;gBACV,MAAM,IAAI;mBACV,MAAM,IAAI;;;;;;;qBAKV,SAAS,GAAG,IAAI;;;;mBAEhB,SAAS,GAAG,IAAI;;;;;4BAChB,SAAS,GAAG,IAAI;;;eAoThB,OAAO,cAAc,EAAE,eAAe;aACtC,OAAO,cAAc,EAAE,eAAe;WACtC,QAAQ;aACR,QAAQ;gBACR,YAAY;eACZ,YAAY;;;;yBAMZ,QAAQ,GAAG,IAAI;yBACf,QAAQ,GAAG,IAAI;;6BA/WsB,WAAW"}

package/src/auction/scheduler.js

@@ -1,6 +1,7 @@
+import { X, Fail, q, makeError } from '@endo/errors';
 import { E } from '@endo/eventual-send';
-import { TimeMath } from '@agoric/time';
 import { Far } from '@endo/marshal';
+import { TimeMath } from '@agoric/time';
 import { makeTracer } from '@agoric/internal';
 import { observeIteration, subscribeEach } from '@agoric/notifier';
 
@@ -11,8 +12,6 @@ import {
   timeVsSchedule,
 } from './scheduleMath.js';
 
-const { details: X, Fail, quote: q } = assert;
-
 const trace = makeTracer('SCHED', true);
 
 // If the startAuction wakeup is no more than 5 minutes late, go ahead with it.
@@ -20,21 +19,22 @@ 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
- * should always be a next schedule, but between rounds, liveSchedule is null.
+ *   Auction round consists of a sequence of steps with decreasing prices. There
+ *   should always be a next schedule, but between rounds, liveSchedule is
+ *   null.
  *
- * The lock period that the liquidators use might start before the previous
- * round has finished, so we need to schedule the next round each time an
- * auction starts. This means if the scheduling parameters change, it'll be a
- * full cycle before we switch. Otherwise, the vaults wouldn't know when to
- * start their lock period. If the lock period for the next auction hasn't
- * started when each aucion ends, we recalculate it, in case the parameters have
- * changed.
+ *   The lock period that the liquidators use might start before the previous
+ *   round has finished, so we need to schedule the next round each time an
+ *   auction starts. This means if the scheduling parameters change, it'll be a
+ *   full cycle before we switch. Otherwise, the vaults wouldn't know when to
+ *   start their lock period. If the lock period for the next auction hasn't
+ *   started when each aucion ends, we recalculate it, in case the parameters
+ *   have changed.
  *
- * If the clock skips forward (because of a chain halt, for instance), the
- * scheduler will try to cleanly and quickly finish any round already in
- * progress. It would take additional work on the manual timer to test this
- * thoroughly.
+ *   If the clock skips forward (because of a chain halt, for instance), the
+ *   scheduler will try to cleanly and quickly finish any round already in
+ *   progress. It would take additional work on the manual timer to test this
+ *   thoroughly.
  */
 
 const makeCancelToken = makeCancelTokenMaker('scheduler');
@@ -49,12 +49,11 @@ const makeCancelToken = makeCancelTokenMaker('scheduler');
 
 /**
  * @typedef {object} ScheduleNotification
- *
- * @property {Timestamp | null} activeStartTime start time of current
- *    auction if auction is active
+ * @property {Timestamp | null} activeStartTime start time of current auction if
+ *   auction is active
  * @property {Timestamp | null} nextStartTime start time of next auction
- * @property {Timestamp | null} nextDescendingStepTime when the next descending step
- *    will take place
+ * @property {Timestamp | null} nextDescendingStepTime when the next descending
+ *   step will take place
  */
 
 const safelyComputeRoundTiming = (params, baseTime) => {
@@ -71,9 +70,9 @@ const nominalStartTime = nextSchedule =>
 
 /**
  * @param {AuctionDriver} auctionDriver
- * @param {import('@agoric/time/src/types').TimerService} timer
+ * @param {import('@agoric/time').TimerService} timer
  * @param {Awaited<import('./params.js').AuctionParamManager>} params
- * @param {import('@agoric/time/src/types').TimerBrand} timerBrand
+ * @param {import('@agoric/time').TimerBrand} timerBrand
  * @param {import('@agoric/zoe/src/contractSupport/recorder.js').Recorder<ScheduleNotification>} scheduleRecorder
  * @param {StoredSubscription<GovernanceSubscriptionState>} paramUpdateSubscription
  */
@@ -92,7 +91,7 @@ export const makeScheduler = async (
    */
   let liveSchedule = null;
 
-  /** @returns {Promise<{ now: Timestamp, nextSchedule: Schedule | null }>} */
+  /** @returns {Promise<{ now: Timestamp; nextSchedule: Schedule | null }>} */
   const initializeNextSchedule = async () => {
     return E.when(
       // XXX manualTimer returns a bigint, not a timeRecord.
@@ -114,7 +113,7 @@ export const makeScheduler = async (
 
   const stepCancelToken = makeCancelToken();
 
-  /** @type {typeof AuctionState[keyof typeof AuctionState]} */
+  /** @type {AuctionState} */
   let auctionState = AuctionState.WAITING;
 
   /**
@@ -149,18 +148,7 @@ export const makeScheduler = async (
       auctionState = AuctionState.WAITING;
       auctionDriver.finalize();
 
-      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 {
+      if (!nextSchedule) {
         console.error(
           '🛠️ finishAuctionRound without scheduling the next; repair with new auctioneer params',
         );
@@ -233,9 +221,13 @@ export const makeScheduler = async (
       liveSchedule.clockStep,
       Far('PriceStepWaker', {
         wake(time) {
-          setTimeMonotonically(time);
-          trace('wake step', now);
-          void clockTick(liveSchedule);
+          try {
+            setTimeMonotonically(time);
+            trace('wake step', now);
+            clockTick(liveSchedule);
+          } catch (e) {
+            console.error(`⚠️ Auction threw ${e}. Caught in PriceStepWaker.`);
+          }
         },
       }),
       stepCancelToken,
@@ -249,10 +241,13 @@ export const makeScheduler = async (
       start,
       Far('SchedulerWaker', {
         wake(time) {
-          setTimeMonotonically(time);
-          auctionDriver.capturePrices();
-          // eslint-disable-next-line no-use-before-define
-          return startAuction();
+          try {
+            setTimeMonotonically(time);
+            auctionDriver.capturePrices();
+            return startAuction();
+          } catch (e) {
+            console.error(`⚠️ Auction threw ${e}. Caught in SchedulerWaker.`);
+          }
         },
       }),
     );
@@ -266,7 +261,7 @@ export const makeScheduler = async (
 
     if (!nextSchedule) {
       console.error(
-        assert.error(X`tried to start auction when none is scheduled`),
+        makeError(X`tried to start auction when none is scheduled`),
       );
       return;
     }
@@ -333,7 +328,18 @@ export const makeScheduler = async (
       // NB: may be fired with the initial params as well
       async updateState(_newState) {
         trace('received param update', _newState);
+        await null;
+
+        let fixableSchedule;
         if (!nextSchedule) {
+          fixableSchedule = true;
+        } else {
+          now = await E(timer).getCurrentTimestamp();
+          fixableSchedule =
+            TimeMath.compareAbs(nextSchedule.startTime, now) < 0;
+        }
+
+        if (fixableSchedule) {
           trace('repairing nextSchedule and restarting');
           ({ nextSchedule } = await initializeNextSchedule());
           startSchedulingFromScratch();
@@ -354,8 +360,8 @@ export const makeScheduler = async (
 
 /**
  * @typedef {object} Schedule
- * @property {import('@agoric/time/src/types').TimestampRecord} startTime
- * @property {import('@agoric/time/src/types').TimestampRecord} endTime
+ * @property {import('@agoric/time').TimestampRecord} startTime
+ * @property {import('@agoric/time').TimestampRecord} endTime
  * @property {NatValue} steps
  * @property {NatValue} endRate
  * @property {RelativeTime} startDelay

package/src/auction/sortedOffers.d.ts

@@ -0,0 +1,8 @@
+export function toPartialOfferKey(offerPrice: Ratio): string;
+export function toPriceOfferKey(offerPrice: Ratio, sequenceNumber: bigint): string;
+export function fromPriceOfferKey(key: string, numBrand: Brand<"nat">, denomBrand: Brand<"nat">, useDecimals: number): [normalizedPrice: Ratio, sequenceNumber: bigint];
+/** @type {(rate: Ratio) => string} */
+export const toBidScalingComparator: (rate: Ratio) => string;
+export function toScaledRateOfferKey(rate: Ratio, sequenceNumber: bigint): string;
+export function fromScaledRateOfferKey(key: string, brand: Brand, useDecimals: number): [normalizedPrice: Ratio, sequenceNumber: bigint];
+//# sourceMappingURL=sortedOffers.d.ts.map

package/src/auction/sortedOffers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortedOffers.d.ts","sourceRoot":"","sources":["sortedOffers.js"],"names":[],"mappings":"AA6BO,8CAFI,KAAK,UAMf;AAUM,4CALI,KAAK,kBACL,MAAM,GACJ,MAAM,CAWlB;AAqCM,uCANI,MAAM,YACN,KAAK,CAAC,KAAK,CAAC,cACZ,KAAK,CAAC,KAAK,CAAC,eACZ,MAAM,GACJ,CAAC,eAAe,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,CAAC,CAS5D;AAED,sCAAsC;AACtC,qCADW,CAAC,IAAI,EAAE,KAAK,KAAK,MAAM,CAKhC;AAUK,2CALI,KAAK,kBACL,MAAM,GACJ,MAAM,CAWlB;AAUM,4CALI,MAAM,SACN,KAAK,eACL,MAAM,GACJ,CAAC,eAAe,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,CAAC,CAQ5D"}

package/src/auction/sortedOffers.js

@@ -1,5 +1,6 @@
 // @jessie-check
 
+import { Fail } from '@endo/errors';
 import {
   makeRatio,
   ratioToNumber,
@@ -9,16 +10,15 @@ import { RatioShape } from '@agoric/ertp';
 
 import { decodeData, encodeData } from '../vaultFactory/storeUtils.js';
 
-const { Fail } = assert;
-
 /**
  * @file we use a floating point representation of the price or rate as the
- * first part of the key in the store. The second part is the sequence number of
- * the bid, but it doesn't matter for sorting. When we retrieve multiple bids,
- * it's only by bid value, so we don't care how the sequence numbers sort.
+ *   first part of the key in the store. The second part is the sequence number
+ *   of the bid, but it doesn't matter for sorting. When we retrieve multiple
+ *   bids, it's only by bid value, so we don't care how the sequence numbers
+ *   sort.
  *
- * We take advantage of the fact that encodeData takes a passable and turns it
- * into a sort key. Arrays of passable data sort like composite keys.
+ *   We take advantage of the fact that encodeData takes a passable and turns it
+ *   into a sort key. Arrays of passable data sort like composite keys.
  */
 
 /**
@@ -39,7 +39,7 @@ export const toPartialOfferKey = offerPrice => {
  * @param {Ratio} offerPrice IST/collateral
  * @param {bigint} sequenceNumber
  * @returns {string} lexically sortable string in which highest price is first,
- *    ties will be broken by sequenceNumber of offer
+ *   ties will be broken by sequenceNumber of offer
  */
 export const toPriceOfferKey = (offerPrice, sequenceNumber) => {
   mustMatch(offerPrice, RatioShape);
@@ -87,6 +87,7 @@ const bidScalingRatioFromKey = (bidScaleFloat, numBrand, useDecimals) => {
  * @returns {[normalizedPrice: Ratio, sequenceNumber: bigint]}
  */
 export const fromPriceOfferKey = (key, numBrand, denomBrand, useDecimals) => {
+  // @ts-expect-error XXX
   const [pricePart, sequenceNumberPart] = decodeData(key);
   return [
     priceRatioFromFloat(pricePart, numBrand, denomBrand, useDecimals),
@@ -107,7 +108,7 @@ export const toBidScalingComparator = rate => {
  * @param {Ratio} rate discount/markup rate expressed as a ratio IST/IST
  * @param {bigint} sequenceNumber
  * @returns {string} lexically sortable string in which highest price is first,
- *    ties will be broken by sequenceNumber of offer
+ *   ties will be broken by sequenceNumber of offer
  */
 export const toScaledRateOfferKey = (rate, sequenceNumber) => {
   mustMatch(rate, RatioShape);

package/src/auction/util.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Constants for Auction State.
+ */
+export type AuctionState = (typeof AuctionState)[keyof typeof AuctionState];
+export namespace AuctionState {
+    let ACTIVE: "active";
+    let WAITING: "waiting";
+}
+export function makeBrandedRatioPattern(numeratorAmountShape: {
+    brand: Brand;
+    value: Pattern;
+}, denominatorAmountShape: {
+    brand: Brand;
+    value: Pattern;
+}): {
+    numerator: {
+        brand: Brand;
+        value: Pattern;
+    };
+    denominator: {
+        brand: Brand;
+        value: Pattern;
+    };
+};
+export function isScaledBidPriceHigher(bidScaling: Ratio, currentPrice: Ratio, oraclePrice: Ratio): boolean;
+/** @type {(quote: PriceQuote) => Ratio} */
+export const priceFrom: (quote: PriceQuote) => Ratio;
+export function makeCancelTokenMaker(name: any): () => RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {}>;
+import type { Pattern } from '@endo/patterns';
+import type { PriceQuote } from '@agoric/zoe/tools/types.js';
+//# sourceMappingURL=util.d.ts.map

package/src/auction/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["util.js"],"names":[],"mappings":";;;2BAiBU,CAAC,OAAO,YAAY,EAAE,MAAM,OAAO,YAAY,CAAC;;;;;AAYnD,8DAHI;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,0BAChC;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE;;eADvB,KAAK;eAAS,OAAO;;;eACrB,KAAK;eAAS,OAAO;;EAUxC;AASM,mDANI,KAAK,gBACL,KAAK,eACL,KAAK,GACH,OAAO,CAI6C;AAEjE,2CAA2C;AAC3C,wBADW,CAAC,KAAK,EAAE,UAAU,KAAK,KAAK,CAKnC;AAEG,oJAIN;6BAlD8B,gBAAgB;gCAC8C,4BAA4B"}

package/src/auction/util.js

@@ -7,19 +7,25 @@ import {
 } from '@agoric/zoe/src/contractSupport/index.js';
 import { Far } from '@endo/marshal';
 
+/**
+ * @import {Key, Pattern} from '@endo/patterns';
+ * @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js';
+ */
+
 /**
  * Constants for Auction State.
  *
- * @type {{ ACTIVE: 'active', WAITING: 'waiting' }}
+ * @enum {(typeof AuctionState)[keyof typeof AuctionState]}
  */
-export const AuctionState = {
+export const AuctionState = /** @type {const} */ ({
   ACTIVE: 'active',
   WAITING: 'waiting',
-};
+});
+harden(AuctionState);
 
 /**
- * @param {{ brand: Brand, value: Pattern }} numeratorAmountShape
- * @param {{ brand: Brand, value: Pattern }} denominatorAmountShape
+ * @param {{ brand: Brand; value: Pattern }} numeratorAmountShape
+ * @param {{ brand: Brand; value: Pattern }} denominatorAmountShape
  */
 export const makeBrandedRatioPattern = (
   numeratorAmountShape,
@@ -36,7 +42,7 @@ export const makeBrandedRatioPattern = (
  * @param {Ratio} currentPrice
  * @param {Ratio} oraclePrice
  * @returns {boolean} TRUE iff the discount(/markup) applied to the price is
- *          higher than the quote.
+ *   higher than the quote.
  */
 export const isScaledBidPriceHigher = (bidScaling, currentPrice, oraclePrice) =>
   ratioGTE(multiplyRatios(oraclePrice, bidScaling), currentPrice);