@agoric/inter-protocol 0.16.1 → 0.16.2-calypso-dev-84eb287.0

package/src/auction/offerBook.d.ts

@@ -0,0 +1,45 @@
+export function prepareScaledBidBook(baggage: Baggage): (bidScalingPattern: globalThis.Pattern, collateralBrand: globalThis.Brand) => import("@endo/exo").Guarded<{
+    /**
+     * @param {ZCFSeat} seat
+     * @param {Ratio} bidScaling
+     * @param {Amount<'nat'>} wanted
+     * @param {boolean} exitAfterBuy
+     */
+    add(seat: ZCFSeat, bidScaling: Ratio, wanted: Amount<"nat">, exitAfterBuy: boolean): string;
+    /** @param {Ratio} bidScaling */
+    offersAbove(bidScaling: Ratio): [string, BidderRecord][];
+    hasOrders(): boolean;
+    delete(key: any): void;
+    updateReceived(key: any, sold: any): void;
+    exitAllSeats(): void;
+}>;
+export function preparePriceBook(baggage: Baggage): (priceRatioPattern: globalThis.Pattern, collateralBrand: globalThis.Brand) => import("@endo/exo").Guarded<{
+    /**
+     * @param {ZCFSeat} seat
+     * @param {Ratio} price
+     * @param {Amount<'nat'>} wanted
+     * @param {boolean} exitAfterBuy
+     */
+    add(seat: ZCFSeat, price: Ratio, wanted: Amount<"nat">, exitAfterBuy: boolean): string;
+    offersAbove(price: any): [string, BidderRecord][];
+    hasOrders(): boolean;
+    delete(key: any): void;
+    updateReceived(key: any, sold: any): void;
+    exitAllSeats(): void;
+}>;
+export type BidderRecord = {
+    seat: ZCFSeat;
+    wanted: Amount<"nat">;
+    seqNum: NatValue;
+    received: Amount<"nat">;
+} & {
+    exitAfterBuy: boolean;
+} & ({
+    bidScaling: Pattern;
+    price: undefined;
+} | {
+    bidScaling: undefined;
+    price: Ratio;
+});
+import type { Baggage } from '@agoric/vat-data';
+//# sourceMappingURL=offerBook.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"offerBook.d.ts","sourceRoot":"","sources":["offerBook.js"],"names":[],"mappings":"AAkDO,8CAFI,OAAO,wFA2Ke,WAC5B;IA1JC;;;;;OAKG;cAJQ,OAAO,cACP,KAAK,UACL,MAAM,CAAC,KAAK,CAAC,gBACb,OAAO;IAsBlB,gCAAgC;4BAApB,KAAK;;;;;GAqCpB;AAcI,0CAFI,OAAO,wFA8Ee,WAC5B;IA7DC;;;;;OAKG;cAJQ,OAAO,SACP,KAAK,UACL,MAAM,CAAC,KAAK,CAAC,gBACb,OAAO;;;;;;GA0DrB;2BAnMU;IACZ,IAAQ,EAAE,OAAO,CAAC;IAClB,MAAU,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1B,MAAU,EAAE,QAAQ,CAAC;IACrB,QAAY,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;CACzB,GAAG;IAAE,YAAY,EAAE,OAAO,CAAA;CAAE,GAAG,CAC1B;IAAE,UAAU,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GACzC;IAAE,UAAU,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAC1C;6BApBqB,kBAAkB"}

package/src/auction/offerBook.js

@@ -12,7 +12,7 @@ import {
   toScaledRateOfferKey,
 } from './sortedOffers.js';
 
-/** @typedef {import('@agoric/vat-data').Baggage} Baggage */
+/** @import {Baggage} from '@agoric/vat-data' */
 
 // multiple offers might be provided at the same time (since the time
 // granularity is limited to blocks), so we increment a sequenceNumber with each
@@ -25,12 +25,14 @@ const nextSequenceNumber = () => {
 
 /**
  * @typedef {{
- * seat: ZCFSeat,
- * wanted: Amount<'nat'>,
- * seqNum: NatValue,
- * received: Amount<'nat'>,
- * } &  {exitAfterBuy: boolean} & ({ bidScaling: Pattern, price: undefined } | { bidScaling: undefined, price: Ratio})
- * } BidderRecord
+ *   seat: ZCFSeat;
+ *   wanted: Amount<'nat'>;
+ *   seqNum: NatValue;
+ *   received: Amount<'nat'>;
+ * } & { exitAfterBuy: boolean } & (
+ *     | { bidScaling: Pattern; price: undefined }
+ *     | { bidScaling: undefined; price: Ratio }
+ *   )} BidderRecord
  */
 
 const ScaledBidBookStateShape = harden({
@@ -41,7 +43,8 @@ const ScaledBidBookStateShape = harden({
 
 /**
  * Prices in this book are expressed as percentage of the full oracle price
- * snapshot taken when the auction started. .4 is 60% off. 1.1 is 10% above par.
+ * snapshot taken when the auction started. .4 is 60% off. 1.1 is 10% above
+ * par.
  *
  * @param {Baggage} baggage
  */
@@ -51,7 +54,6 @@ export const prepareScaledBidBook = baggage =>
     'scaledBidBook',
     undefined,
     /**
-     *
      * @param {Pattern} bidScalingPattern
      * @param {Brand} collateralBrand
      */
@@ -134,8 +136,8 @@ const PriceBookStateShape = harden({
 });
 
 /**
- * Prices in this book are actual prices expressed in terms of bid amount
- * and collateral amount.
+ * Prices in this book are actual prices expressed in terms of bid amount and
+ * collateral amount.
  *
  * @param {Baggage} baggage
  */
@@ -145,7 +147,6 @@ export const preparePriceBook = baggage =>
     'priceBook',
     undefined,
     /**
-     *
      * @param {Pattern} priceRatioPattern
      * @param {Brand} collateralBrand
      */

package/src/auction/params.d.ts

@@ -0,0 +1,144 @@
+/**
+ * @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';
+ */
+export const InvitationShape: import("@endo/patterns").Matcher;
+/**
+ * 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
+ * START_FREQUENCY has elapsed.
+ */
+export const START_FREQUENCY: "StartFrequency";
+/** in seconds, how often to reduce the price */
+export const CLOCK_STEP: "ClockStep";
+/** discount or markup for starting price in basis points. 9999 = 1bp discount */
+export const STARTING_RATE_BP: "StartingRate";
+/** A limit below which the price will not be discounted. */
+export const LOWEST_RATE_BP: "LowestRate";
+/** amount to reduce prices each time step in bp, as % of the start price */
+export const DISCOUNT_STEP_BP: "DiscountStep";
+/**
+ * VaultManagers liquidate vaults at a frequency configured by START_FREQUENCY.
+ * Auctions start this long after the hour to give vaults time to finish.
+ */
+export const AUCTION_START_DELAY: "AuctionStartDelay";
+export const PRICE_LOCK_PERIOD: "PriceLockPeriod";
+export const auctioneerParamPattern: import("@endo/patterns").Matcher;
+export namespace auctioneerParamTypes {
+    let Electorate: "invitation";
+    let StartFrequency: "relativeTime";
+    let ClockStep: "relativeTime";
+    let StartingRate: "nat";
+    let LowestRate: "nat";
+    let DiscountStep: "nat";
+    let AuctionStartDelay: "relativeTime";
+    let PriceLockPeriod: "relativeTime";
+}
+export function makeAuctioneerParams({ ElectorateInvitationAmount, StartFrequency, ClockStep, LowestRate, StartingRate, DiscountStep, AuctionStartDelay, PriceLockPeriod, TimerBrand, }: AuctionParams): {
+    Electorate: {
+        type: "invitation";
+        value: import("@agoric/ertp/src/types").SetAmount<import("@endo/patterns").Key>;
+    };
+    StartFrequency: {
+        type: "relativeTime";
+        value: import("@agoric/time").RelativeTimeRecord;
+    };
+    ClockStep: {
+        type: "relativeTime";
+        value: import("@agoric/time").RelativeTimeRecord;
+    };
+    AuctionStartDelay: {
+        type: "relativeTime";
+        value: import("@agoric/time").RelativeTimeRecord;
+    };
+    PriceLockPeriod: {
+        type: "relativeTime";
+        value: import("@agoric/time").RelativeTimeRecord;
+    };
+    StartingRate: {
+        type: "nat";
+        value: bigint;
+    };
+    LowestRate: {
+        type: "nat";
+        value: bigint;
+    };
+    DiscountStep: {
+        type: "nat";
+        value: bigint;
+    };
+};
+export function makeAuctioneerParamManager(publisherKit: import("@agoric/notifier").StoredPublisherKit<GovernanceSubscriptionState>, zcf: ZCF, initial: AuctionParams): import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+    Electorate: "invitation";
+    StartFrequency: "relativeTime";
+    ClockStep: "relativeTime";
+    StartingRate: "nat";
+    LowestRate: "nat";
+    DiscountStep: "nat";
+    AuctionStartDelay: "relativeTime";
+    PriceLockPeriod: "relativeTime";
+}>;
+export function makeGovernedTerms({ storageNode: _storageNode, marshaller: _marshaller }: {
+    storageNode: ERef<StorageNode>;
+    marshaller: ERef<Marshaller>;
+}, timer: ERef<import("@agoric/time").TimerService>, priceAuthority: ERef<PriceAuthority>, reservePublicFacet: ERef<AssetReservePublicFacet>, params: AuctionParams): {
+    priceAuthority: globalThis.ERef<PriceAuthority>;
+    reservePublicFacet: globalThis.ERef<globalThis.GovernedPublicFacet<import("@endo/exo").Guarded<{
+        makeAddCollateralInvitation(): Promise<Invitation<string, never>>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport").PublicTopic<import("../reserve/assetReserveKit").MetricsNotification>;
+        };
+    }>>>;
+    timerService: globalThis.ERef<import("@agoric/time").TimerService>;
+    governedParams: {
+        Electorate: {
+            type: "invitation";
+            value: import("@agoric/ertp/src/types").SetAmount<import("@endo/patterns").Key>;
+        };
+        StartFrequency: {
+            type: "relativeTime";
+            value: import("@agoric/time").RelativeTimeRecord;
+        };
+        ClockStep: {
+            type: "relativeTime";
+            value: import("@agoric/time").RelativeTimeRecord;
+        };
+        AuctionStartDelay: {
+            type: "relativeTime";
+            value: import("@agoric/time").RelativeTimeRecord;
+        };
+        PriceLockPeriod: {
+            type: "relativeTime";
+            value: import("@agoric/time").RelativeTimeRecord;
+        };
+        StartingRate: {
+            type: "nat";
+            value: bigint;
+        };
+        LowestRate: {
+            type: "nat";
+            value: bigint;
+        };
+        DiscountStep: {
+            type: "nat";
+            value: bigint;
+        };
+    };
+};
+export type AuctionParams = {
+    ElectorateInvitationAmount: Amount<"set">;
+    StartFrequency: RelativeTime;
+    ClockStep: RelativeTime;
+    StartingRate: bigint;
+    LowestRate: bigint;
+    DiscountStep: bigint;
+    AuctionStartDelay: RelativeTime;
+    PriceLockPeriod: RelativeTime;
+    TimerBrand: import("@agoric/time").TimerBrand;
+};
+export type AuctionParamManager = ReturnType<typeof makeAuctioneerParamManager>;
+import type { PriceAuthority } from '@agoric/zoe/tools/types.js';
+//# sourceMappingURL=params.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["params.js"],"names":[],"mappings":"AAQA;;;;GAIG;AAGH,+DAAyD;AAEzD;;;;;;GAMG;AACH,+CAAgD;AAChD,gDAAgD;AAChD,qCAAsC;AACtC,iFAAiF;AACjF,8CAA+C;AAC/C,4DAA4D;AAC5D,0CAA2C;AAC3C,4EAA4E;AAC5E,8CAA+C;AAC/C;;;GAGG;AACH,sDAAuD;AAIvD,kDAAmD;AAEnD,sEASG;;;;;;;;;;;AA2BI,yLADK,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCxB;AAQM,yDAJI,OAAO,kBAAkB,EAAE,kBAAkB,CAAC,2BAA2B,CAAC,OAC1E,GAAG,WACH,aAAa;;;;;;;;;GA0BvB;AAUM,0FANI;IAAE,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;IAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAA;CAAE,SAChE,IAAI,CAAC,OAAO,cAAc,EAAE,YAAY,CAAC,kBACzC,IAAI,CAAC,cAAc,CAAC,sBACpB,IAAI,CAAC,uBAAuB,CAAC,UAC7B,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBvB;;gCAxGa,MAAM,CAAC,KAAK,CAAC;oBACb,YAAY;eACZ,YAAY;kBACZ,MAAM;gBACN,MAAM;kBACN,MAAM;uBACN,YAAY;qBACZ,YAAY;gBACZ,OAAO,cAAc,EAAE,UAAU;;kCAmGjC,UAAU,CAAC,OAAO,0BAA0B,CAAC;oCAnKkC,4BAA4B"}

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,
@@ -148,8 +149,8 @@ export const makeAuctioneerParamManager = (publisherKit, zcf, initial) => {
 harden(makeAuctioneerParamManager);
 
 /**
- * @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;qCAjKkC,cAAc"}

package/src/auction/scheduleMath.js

@@ -4,6 +4,8 @@ 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;
 
@@ -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,49 @@
+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: () => "active" | "waiting";
+} & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+    getSchedule: () => {
+        liveAuctionSchedule: Schedule | null;
+        nextAuctionSchedule: Schedule | null;
+    };
+    getAuctionState: () => "active" | "waiting";
+}>>;
+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;
+};
+//# 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":"AA+EO,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;;;;;;;;;;;;IA2RzD;;yBA5Ta,MAAM,IAAI;cACV,MAAM,IAAI;gBACV,MAAM,IAAI;mBACV,MAAM,IAAI;;;;;;;qBAKV,SAAS,GAAG,IAAI;;;;mBAEhB,SAAS,GAAG,IAAI;;;;;4BAChB,SAAS,GAAG,IAAI;;;eAqThB,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"}

package/src/auction/scheduler.js

@@ -20,21 +20,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 +50,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 +71,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 +92,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 +114,7 @@ export const makeScheduler = async (
 
   const stepCancelToken = makeCancelToken();
 
-  /** @type {typeof AuctionState[keyof typeof AuctionState]} */
+  /** @type {(typeof AuctionState)[keyof typeof AuctionState]} */
   let auctionState = AuctionState.WAITING;
 
   /**
@@ -149,18 +149,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 +222,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 +242,14 @@ 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();
+            // eslint-disable-next-line no-use-before-define
+            return startAuction();
+          } catch (e) {
+            console.error(`⚠️ Auction threw ${e}. Caught in SchedulerWaker.`);
+          }
         },
       }),
     );
@@ -333,7 +330,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 +362,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":"AA8BO,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"}