@agoric/inter-protocol 0.16.2-upgrade-14-dev-0169c7e.0 → 0.16.2-upgrade-16-dev-8879538.0

package/src/price/roundsManager.d.ts

@@ -0,0 +1,238 @@
+/** @type {bigint} */
+export const ROUND_MAX: bigint;
+export function prepareRoundsManagerKit(baggage: any): (args_0: Readonly<import("./fluxAggregatorKit.js").ChainlinkConfig & {
+    quoteKit: QuoteKit;
+    answerPublisher: Publisher<void>;
+    brandIn: Brand<"nat">;
+    brandOut: Brand<"nat">;
+    latestRoundPublisher: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<LatestRound>;
+    timerPresence: TimerService;
+}> & {
+    unitAmountIn: Amount<"nat">;
+}) => import("@endo/exo").GuardedKit<{
+    helper: {
+        /** @param {bigint} roundId */
+        acceptingSubmissions(roundId: bigint): boolean;
+        /**
+         * @param {OracleStatus} status
+         * @param {bigint} roundId
+         */
+        delayed(status: OracleStatus, roundId: bigint): boolean;
+        /** @param {bigint} roundId */
+        deleteRoundDetails(roundId: bigint): void;
+        /** @param {bigint} roundId */
+        isNextRound(roundId: bigint): boolean;
+        /**
+         * @param {bigint} roundId
+         * @param {Timestamp} blockTimestamp
+         * @param {string} oracleId
+         */
+        initializeNewRound(roundId: bigint, blockTimestamp: Timestamp, oracleId: string): void;
+        /**
+         * @param {bigint} roundId
+         * @param {bigint} rrId reporting round ID
+         */
+        previousAndCurrentUnanswered(roundId: bigint, rrId: bigint): boolean;
+        /**
+         * @param {bigint} roundId
+         * @param {OracleStatus} status
+         * @param {Timestamp} blockTimestamp
+         * @returns {OracleStatus | undefined} the new status
+         */
+        proposeNewRound(roundId: bigint, status: OracleStatus, blockTimestamp: Timestamp): OracleStatus | undefined;
+        /**
+         * @param {bigint} submission
+         * @param {bigint} roundId
+         * @param {OracleStatus} status
+         * @returns {OracleStatus} the new status
+         */
+        recordSubmission(submission: bigint, roundId: bigint, status: OracleStatus): OracleStatus;
+        /**
+         * @param {bigint} roundId
+         * @param {Timestamp} blockTimestamp
+         */
+        supersedable(roundId: bigint, blockTimestamp: Timestamp): boolean;
+        /**
+         * @param {bigint} roundId
+         * @param {Timestamp} blockTimestamp
+         */
+        timedOut(roundId: bigint, blockTimestamp: Timestamp): boolean;
+        /**
+         * @param {bigint} roundId
+         * @param {Timestamp} blockTimestamp
+         */
+        updateRoundAnswer(roundId: bigint, blockTimestamp: Timestamp): (number | boolean)[] | (bigint | boolean)[];
+        /**
+         * @param {bigint} roundId
+         * @param {Timestamp} blockTimestamp
+         */
+        updateTimedOutRoundInfo(roundId: bigint, blockTimestamp: Timestamp): void;
+        /**
+         * @param {OracleStatus} status
+         * @param {bigint} roundId
+         * @param {Timestamp} blockTimestamp
+         * @returns {string | null} error message, if there is one
+         */
+        validateOracleRound(status: OracleStatus, roundId: bigint, blockTimestamp: Timestamp): string | null;
+    };
+    contract: {
+        /** @param {PriceQuoteValue} quote */
+        authenticateQuote(quote: PriceQuoteValue): Promise<{
+            quoteAmount: import("@agoric/ertp/src/types.js").SetAmount<PriceDescription>;
+            quotePayment: globalThis.Payment<"set", PriceDescription>;
+        }>;
+        /**
+         * @param {object} param0
+         * @param {number} [param0.overrideValueOut]
+         * @param {Timestamp} [param0.timestamp]
+         */
+        makeCreateQuote({ overrideValueOut, timestamp }?: {
+            overrideValueOut?: number | undefined;
+            timestamp?: Timestamp | undefined;
+        }): ((priceQuery: any) => Promise<{
+            quoteAmount: import("@agoric/ertp/src/types.js").SetAmount<PriceDescription>;
+            quotePayment: globalThis.Payment<"set", PriceDescription>;
+        }> | undefined) & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, (priceQuery: any) => Promise<{
+            quoteAmount: import("@agoric/ertp/src/types.js").SetAmount<PriceDescription>;
+            quotePayment: globalThis.Payment<"set", PriceDescription>;
+        }> | undefined>;
+        /**
+         * @param {OracleStatus} status
+         * @param {bigint} queriedRoundId
+         * @param {Timestamp} blockTimestamp
+         */
+        eligibleForSpecificRound(status: OracleStatus, queriedRoundId: bigint, blockTimestamp: Timestamp): boolean;
+        /**
+         * consumers are encouraged to check that they're receiving fresh data
+         * by inspecting the updatedAt and answeredInRound return values.
+         *
+         * @param {bigint | number} roundIdRaw
+         * @returns {Promise<RoundData>}
+         */
+        getRoundData(roundIdRaw: bigint | number): Promise<RoundData>;
+        /** @type {(roundId: bigint) => Readonly<RoundDetails & Round>} */
+        getRoundStatus(roundId: bigint): Readonly<RoundDetails & Round>;
+        /**
+         * a method to provide all current info oracleStatuses need. Intended
+         * only only to be callable by oracleStatuses. Not for use by contracts
+         * to read state.
+         *
+         * @param {OracleStatus} status
+         * @param {Timestamp} blockTimestamp
+         */
+        oracleRoundStateSuggestRound(status: OracleStatus, blockTimestamp: Timestamp): {
+            eligibleForSpecificRound: boolean;
+            queriedRoundId: bigint;
+            latestSubmission: bigint;
+            startedAt: Timestamp;
+            roundTimeout: number;
+        };
+    };
+    oracle: {
+        /**
+         * push a unitPrice result from this oracle
+         *
+         * @param {OracleStatus} status
+         * @param {PriceRound} result
+         */
+        handlePush(status: OracleStatus, { roundId: roundIdRaw, unitPrice: valueRaw }: PriceRound): Promise<OracleStatus>;
+    };
+}>;
+export type PriceRound = {
+    roundId: number | undefined;
+    unitPrice: NatValue;
+};
+export type LatestRound = Pick<RoundData, "roundId" | "startedAt"> & {
+    startedBy: string;
+};
+export type RoundData = Round & {
+    roundId: bigint;
+};
+export type Round = {
+    /**
+     * the answer for the given round
+     */
+    answer: bigint;
+    /**
+     * the timestamp when the round was started.
+     * This is 0 if the round hasn't been started yet.
+     */
+    startedAt: Timestamp;
+    /**
+     * the timestamp when the round last was updated
+     * (i.e. answer was last computed)
+     */
+    updatedAt: Timestamp;
+    /**
+     * the round ID of the round in which the
+     * answer was computed. answeredInRound may be smaller than roundId when the
+     * round timed out. answeredInRound is equal to roundId when the round didn't
+     * time out and was completed regularly.
+     */
+    answeredInRound: bigint;
+};
+export type RoundDetails = {
+    submissions: bigint[];
+    maxSubmissions: number;
+    minSubmissions: number;
+    roundTimeout: number;
+};
+export type QuoteKit = {
+    mint: globalThis.Mint<"set", PriceDescription>;
+    /**
+     * Externally useful only if this
+     * issuer uses recovery sets. Can be used to get the recovery set associated
+     * with minted payments that are still live.
+     */
+    mintRecoveryPurse: globalThis.Purse<"set", PriceDescription>;
+    issuer: globalThis.Issuer<"set", PriceDescription>;
+    brand: globalThis.Brand<"set">;
+    displayInfo: globalThis.DisplayInfo;
+};
+export type HeldParams = {
+    readonly maxSubmissionCount: number;
+    readonly minSubmissionCount: number;
+    /**
+     * the number of rounds an Oracle has to wait
+     * before they can initiate a round
+     */
+    readonly restartDelay: bigint;
+    /**
+     * an immutable check for a lower bound of
+     * what submission values are accepted from an oracle
+     */
+    readonly minSubmissionValue: number;
+    /**
+     * an immutable check for an upper bound
+     * of what submission values are accepted from an oracle
+     */
+    readonly maxSubmissionValue: number;
+    /**
+     * the number of seconds after the previous round
+     * that allowed to lapse before allowing an oracle to skip an unfinished
+     * round
+     */
+    readonly timeout: number;
+    readonly quoteKit: QuoteKit;
+    readonly answerPublisher: Publisher<void>;
+    readonly brandIn: Brand<"nat">;
+    readonly brandOut: Brand<"nat">;
+    readonly latestRoundPublisher: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<LatestRound>;
+    readonly timerPresence: TimerService;
+};
+export type ImmutableState = Readonly<HeldParams & {
+    details: MapStore<bigint, RoundDetails>;
+    rounds: MapStore<bigint, Round>;
+    unitIn: bigint;
+}>;
+export type MutableState = {
+    lastValueOutForUnitIn: bigint | null;
+    reportingRoundId: bigint;
+};
+export type State = ImmutableState & MutableState;
+import type { TimerService } from '@agoric/time';
+import type { OracleStatus } from './priceOracleKit.js';
+import type { Timestamp } from '@agoric/time';
+import type { PriceQuoteValue } from '@agoric/zoe/tools/types.js';
+import type { PriceDescription } from '@agoric/zoe/tools/types.js';
+//# sourceMappingURL=roundsManager.d.ts.map

package/src/price/roundsManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roundsManager.d.ts","sourceRoot":"","sources":["roundsManager.js"],"names":[],"mappings":"AAyBA,qBAAqB;AACrB,wBADW,MAAM,CAC4B;AAmEtC;cAxBU,QAAQ;qBACD,SAAS,CAAC,IAAI,CAAC;aACvB,KAAK,CAAC,KAAK,CAAC;cACX,KAAK,CAAC,KAAK,CAAC;0BACA,OAAO,6CAA6C,EAAE,QAAQ,CAAC,WAAW,CAAC;;;kBAmD5D,MAAM,CAAC,KAAK,CAAC;;;QAwDjD,8BAA8B;sCAAlB,MAAM;QAQlB;;;WAGG;+CADQ,MAAM;QAQjB,8BAA8B;oCAAlB,MAAM;QASlB,8BAA8B;6BAAlB,MAAM;QAMlB;;;;WAIG;oCAHQ,MAAM,uCAEN,MAAM;QA4CjB;;;WAGG;8CAFQ,MAAM,QACN,MAAM;QAOjB;;;;;WAKG;iCAJQ,MAAM;QAoBjB;;;;;WAKG;qCAJQ,MAAM,WACN,MAAM;QA0BjB;;;WAGG;8BAFQ,MAAM;QAYjB;;;WAGG;0BAFQ,MAAM;QA0BjB;;;WAGG;mCAFQ,MAAM;QAiCjB;;;WAGG;yCAFQ,MAAM;QA4BjB;;;;;WAKG;2DAHQ,MAAM,8BAEJ,MAAM,GAAG,IAAI;;;QA8B1B,qCAAqC;;;;;QAQrC;;;;WAIG;;YAFwB,gBAAgB;YACb,SAAS;;;;;;;;QAwEvC;;;;WAIG;uEAFQ,MAAM;QAoBjB;;;;;;WAMG;iCAFQ,MAAM,GAAG,MAAM,GACb,OAAO,CAAC,SAAS,CAAC;QAwB/B,kEAAkE;gCAA7C,MAAM,GAAK,QAAQ,CAAC,YAAY,GAAG,KAAK,CAAC;QAS9D;;;;;;;WAOG;;;;;;;;;;QAwDH;;;;;WAKG;uFADQ,UAAU;;GA+D1B;yBAprBU;IAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,SAAS,EAAE,QAAQ,CAAA;CAAE;0BAEpD,IAAI,CAAC,SAAS,EAAE,SAAS,GAAG,WAAW,CAAC,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE;wBAG/D,KAAK,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE;;;;;YAI3B,MAAM;;;;;;;;;;;;;;;;;qBAKN,MAAM;;;iBAQN,MAAM,EAAE;oBACR,MAAM;oBACN,MAAM;kBACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAQH,QAAQ;8BACD,SAAS,CAAC,IAAI,CAAC;sBACvB,KAAK,CAAC,KAAK,CAAC;uBACX,KAAK,CAAC,KAAK,CAAC;mCACA,OAAO,6CAA6C,EAAE,QAAQ,CAAC,WAAW,CAAC;;;6BAK3F,QAAQ,CACpB,UAAc,GAAG;IACjB,OAAa,EAAE,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC9C,MAAY,EAAE,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACtC,MAAY,EAAE,MAAM,CAAC;CAChB,CACF;2BAES;IACZ,qBAAyB,EAAE,MAAM,QAAE;IACnC,gBAAoB,EAAE,MAAM,CAAC;CAC1B;oBAEU,cAAc,GAAG,YAAY;kCAzED,cAAc;kCACzB,qBAAqB;+BADV,cAAc;qCADqC,4BAA4B;sCAA5B,4BAA4B"}

package/src/price/roundsManager.js

@@ -1,7 +1,7 @@
 import { Fail, q } from '@agoric/assert';
 import { AmountMath } from '@agoric/ertp';
 import { makeTracer } from '@agoric/internal';
-import { TimeMath } from '@agoric/time';
+import { TimeMath, TimestampShape } from '@agoric/time';
 import { M, makeScalarBigMapStore, prepareExoClassKit } from '@agoric/vat-data';
 import {
   calculateMedian,
@@ -10,14 +10,14 @@ import {
 import { E } from '@endo/eventual-send';
 import { Far } from '@endo/marshal';
 import { isNat, Nat } from '@endo/nat';
-import { UnguardedHelperI } from '../typeGuards.js';
+import { UnguardedHelperI } from '@agoric/internal/src/typeGuards.js';
 
 const { add, subtract, multiply, floorDivide, ceilDivide, isGTE } = natSafeMath;
 
-/** @typedef {import('./priceOracleKit.js').OracleStatus} OracleStatus */
 /**
- * @typedef {import('@agoric/time/src/types').Timestamp} Timestamp
- * @typedef {import('@agoric/time/src/types').TimerService} TimerService
+ * @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js';
+ * @import {Timestamp, TimerService} from '@agoric/time'
+ * @import {OracleStatus} from './priceOracleKit.js'
  */
 
 /** @type {string} */
@@ -28,34 +28,30 @@ export const ROUND_MAX = BigInt(2 ** 32 - 1);
 
 const trace = makeTracer('RoundsM', false);
 
-/**
- * @param {bigint} roundId
- */
+/** @param {bigint} roundId */
 const validRoundId = roundId => {
   return roundId <= ROUND_MAX;
 };
 
 /**
- * @typedef {{ roundId: number | undefined, unitPrice: NatValue }} PriceRound
+ * @typedef {{ roundId: number | undefined; unitPrice: NatValue }} PriceRound
  *
- * @typedef {Pick<RoundData, 'roundId' | 'startedAt'> &  { startedBy: string }} LatestRound
+ * @typedef {Pick<RoundData, 'roundId' | 'startedAt'> & { startedBy: string }} LatestRound
  */
 
-/**
- * @typedef {Round & {roundId: bigint}} RoundData
- */
+/** @typedef {Round & { roundId: bigint }} RoundData */
 
 /**
  * @typedef {object} Round
  * @property {bigint} answer the answer for the given round
- * @property {Timestamp} startedAt the timestamp when the round was started. This is 0
- * if the round hasn't been started yet.
- * @property {Timestamp} updatedAt the timestamp when the round last was updated (i.e.
- * answer was last computed)
- * @property {bigint} answeredInRound the round ID of the round in which the answer
- * was computed. answeredInRound may be smaller than roundId when the round
- * timed out. answeredInRound is equal to roundId when the round didn't time out
- * and was completed regularly.
+ * @property {Timestamp} startedAt the timestamp when the round was started.
+ *   This is 0 if the round hasn't been started yet.
+ * @property {Timestamp} updatedAt the timestamp when the round last was updated
+ *   (i.e. answer was last computed)
+ * @property {bigint} answeredInRound the round ID of the round in which the
+ *   answer was computed. answeredInRound may be smaller than roundId when the
+ *   round timed out. answeredInRound is equal to roundId when the round didn't
+ *   time out and was completed regularly.
  */
 
 /**
@@ -66,29 +62,31 @@ const validRoundId = roundId => {
  * @property {number} roundTimeout
  */
 
-/**
- * @typedef {IssuerKit<'set'>} QuoteKit
- */
+/** @typedef {IssuerKit<'set', PriceDescription>} QuoteKit */
 
 /**
- * @typedef {Readonly<import('./fluxAggregatorKit.js').ChainlinkConfig & {
- * quoteKit: QuoteKit,
- * answerPublisher: Publisher<void>,
- * brandIn: Brand<'nat'>,
- * brandOut: Brand<'nat'>,
- * latestRoundPublisher: import('@agoric/zoe/src/contractSupport/recorder.js').Recorder<LatestRound>,
- * timerPresence: TimerService,
- * }>} HeldParams
+ * @typedef {Readonly<
+ *   import('./fluxAggregatorKit.js').ChainlinkConfig & {
+ *     quoteKit: QuoteKit;
+ *     answerPublisher: Publisher<void>;
+ *     brandIn: Brand<'nat'>;
+ *     brandOut: Brand<'nat'>;
+ *     latestRoundPublisher: import('@agoric/zoe/src/contractSupport/recorder.js').Recorder<LatestRound>;
+ *     timerPresence: TimerService;
+ *   }
+ * >} HeldParams
  *
- * @typedef {Readonly<HeldParams & {
- * details: MapStore<bigint, RoundDetails>,
- * rounds: MapStore<bigint, Round>,
- * unitIn: bigint,
- * }>} ImmutableState
+ * @typedef {Readonly<
+ *   HeldParams & {
+ *     details: MapStore<bigint, RoundDetails>;
+ *     rounds: MapStore<bigint, Round>;
+ *     unitIn: bigint;
+ *   }
+ * >} ImmutableState
  *
  * @typedef {{
- * lastValueOutForUnitIn: bigint?,
- * reportingRoundId: bigint,
+ *   lastValueOutForUnitIn: bigint?;
+ *   reportingRoundId: bigint;
  * }} MutableState
  */
 /** @typedef {ImmutableState & MutableState} State */
@@ -99,24 +97,34 @@ export const prepareRoundsManagerKit = baggage =>
     'RoundsManager',
     {
       helper: UnguardedHelperI,
-      contract: M.interface(
-        'contract',
-        {
-          authenticateQuote: M.call(M.any()).returns(M.any()),
-          makeCreateQuote: M.call().optional(M.any()).returns(M.any()),
-          eligibleForSpecificRound: M.call(M.any()).returns(M.boolean()),
-          getRoundData: M.call(M.any()).returns(M.promise()),
-          getRoundStatus: M.call(M.any()).returns(M.record()),
-          oracleRoundStateSuggestRound: M.call(M.any()).returns(M.record()),
-        },
-        // TODO(6571) stop sloppy
-        { sloppy: true },
-      ),
+      contract: M.interface('contract', {
+        authenticateQuote: M.call([M.record()]).returns(M.any()),
+        makeCreateQuote: M.call()
+          .optional({
+            overrideValueOut: M.number(),
+            timestamp: TimestampShape,
+          })
+          .returns(M.any()),
+        eligibleForSpecificRound: M.call(
+          M.any(),
+          M.bigint(),
+          TimestampShape,
+        ).returns(M.boolean()),
+        getRoundData: M.call(M.any()).returns(M.promise()),
+        getRoundStatus: M.call(M.bigint()).returns(M.record()),
+        oracleRoundStateSuggestRound: M.call(M.any(), TimestampShape).returns(
+          M.record(),
+        ),
+      }),
       oracle: M.interface('oracle', {
         handlePush: M.call(M.record(), M.record()).returns(M.promise()),
       }),
     },
-    /** @type {(opts: HeldParams & { unitAmountIn: Amount<'nat'> }) => State} */
+    /**
+     * @type {(
+     *   opts: HeldParams & { unitAmountIn: Amount<'nat'> },
+     * ) => State}
+     */
     ({
       // ChainlinkConfig
       maxSubmissionCount,
@@ -170,9 +178,7 @@ export const prepareRoundsManagerKit = baggage =>
     },
     {
       helper: {
-        /**
-         * @param {bigint} roundId
-         */
+        /** @param {bigint} roundId */
         acceptingSubmissions(roundId) {
           const { details } = this.state;
           return (
@@ -190,9 +196,7 @@ export const prepareRoundsManagerKit = baggage =>
           return roundId > add(lastStarted, restartDelay) || lastStarted === 0n;
         },
 
-        /**
-         * @param {bigint} roundId
-         */
+        /** @param {bigint} roundId */
         deleteRoundDetails(roundId) {
           const { details } = this.state;
           const roundDetails = details.get(roundId);
@@ -201,9 +205,7 @@ export const prepareRoundsManagerKit = baggage =>
           details.delete(roundId);
         },
 
-        /**
-         * @param {bigint} roundId
-         */
+        /** @param {bigint} roundId */
         isNextRound(roundId) {
           const { reportingRoundId } = this.state;
           return roundId === add(reportingRoundId, 1);
@@ -421,7 +423,7 @@ export const prepareRoundsManagerKit = baggage =>
          * @param {OracleStatus} status
          * @param {bigint} roundId
          * @param {Timestamp} blockTimestamp
-         * @returns {string?} error message, if there is one
+         * @returns {string | null} error message, if there is one
          */
         validateOracleRound(status, roundId, blockTimestamp) {
           const { reportingRoundId } = this.state;
@@ -435,8 +437,10 @@ export const prepareRoundsManagerKit = baggage =>
             );
           }
 
-          if (status.lastReportedRound >= roundId)
+          if (status.lastReportedRound >= roundId) {
             return 'cannot report on previous rounds';
+          }
+
           if (
             roundId !== reportingRoundId &&
             roundId !== add(reportingRoundId, 1) &&
@@ -449,10 +453,7 @@ export const prepareRoundsManagerKit = baggage =>
         },
       },
       contract: {
-        /**
-         *
-         * @param {PriceQuoteValue} quote
-         */
+        /** @param {PriceQuoteValue} quote */
         async authenticateQuote(quote) {
           const { quoteKit } = this.state;
           const quoteAmount = AmountMath.make(quoteKit.brand, harden(quote));
@@ -470,9 +471,7 @@ export const prepareRoundsManagerKit = baggage =>
           const { brandIn, brandOut, timerPresence } = state;
           const { contract } = this.facets;
 
-          /**
-           * @param {PriceQuery} priceQuery
-           */
+          /** @param {PriceQuery} priceQuery */
           return Far('createQuote', priceQuery => {
             const { lastValueOutForUnitIn, unitIn } = state;
 
@@ -486,9 +485,7 @@ export const prepareRoundsManagerKit = baggage =>
               return undefined;
             }
 
-            /**
-             * @param {Amount<'nat'>} amountIn the given amountIn
-             */
+            /** @param {Amount<'nat'>} amountIn the given amountIn */
             const calcAmountOut = amountIn => {
               const valueIn = AmountMath.getValue(brandIn, amountIn);
               return AmountMath.make(
@@ -497,9 +494,7 @@ export const prepareRoundsManagerKit = baggage =>
               );
             };
 
-            /**
-             * @param {Amount<'nat'>} amountOut the wanted amountOut
-             */
+            /** @param {Amount<'nat'>} amountOut the wanted amountOut */
             const calcAmountIn = amountOut => {
               const valueOut = AmountMath.getValue(brandOut, amountOut);
               return AmountMath.make(
@@ -564,9 +559,8 @@ export const prepareRoundsManagerKit = baggage =>
         },
 
         /**
-         * consumers are encouraged to check
-         * that they're receiving fresh data by inspecting the updatedAt and
-         * answeredInRound return values.
+         * consumers are encouraged to check that they're receiving fresh data
+         * by inspecting the updatedAt and answeredInRound return values.
          *
          * @param {bigint | number} roundIdRaw
          * @returns {Promise<RoundData>}
@@ -603,8 +597,9 @@ export const prepareRoundsManagerKit = baggage =>
         },
 
         /**
-         * a method to provide all current info oracleStatuses need. Intended only
-         * only to be callable by oracleStatuses. Not for use by contracts to read state.
+         * a method to provide all current info oracleStatuses need. Intended
+         * only only to be callable by oracleStatuses. Not for use by contracts
+         * to read state.
          *
          * @param {OracleStatus} status
          * @param {Timestamp} blockTimestamp

package/src/proposals/README.md

@@ -1,7 +1,6 @@
 # Proposals
 
-These are code snippets that go into propoals to the BLDer DAO to start the Inter Protocol.
+These scripts are referenced by proposals to the BLDer DAO to run on the chain.
 
-One of the latest is `startPSM.js` so best to model after that. The style in `econ-behaviors.js` will be refactored to be like startPSM.
+See the documentation in .../deploy-script-support/README.md
 
-[syntax of the manifests](../../packages/vats/src/core/manifest.js)

package/src/proposals/add-auction.d.ts

@@ -0,0 +1,69 @@
+export function addAuction({ consume: { zoe, board, chainTimerService, priceAuthority, chainStorage, economicCommitteeCreatorFacet: electorateCreatorFacet, auctioneerKit: legacyKitP, }, produce: { newAuctioneerKit }, instance: { consume: { reserve: reserveInstance }, }, installation: { consume: { auctioneer: auctionInstallation, contractGovernor: contractGovernorInstallation, }, }, issuer: { consume: { [Stable.symbol]: stableIssuerP }, }, }: import("./econ-behaviors.js").EconomyBootstrapPowers): Promise<void>;
+export const ADD_AUCTION_MANIFEST: {
+    [x: string]: {
+        consume: {
+            zoe: boolean;
+            board: boolean;
+            chainTimerService: boolean;
+            priceAuthority: boolean;
+            chainStorage: boolean;
+            economicCommitteeCreatorFacet: boolean;
+            auctioneerKit: boolean;
+        };
+        produce: {
+            newAuctioneerKit: boolean;
+        };
+        instance: {
+            consume: {
+                reserve: boolean;
+            };
+        };
+        installation: {
+            consume: {
+                auctioneer: boolean;
+                contractGovernor: boolean;
+            };
+        };
+        issuer: {
+            consume: {
+                IST: boolean;
+            };
+        };
+    };
+};
+export function getManifestForAddAuction(): Promise<{
+    manifest: {
+        [x: string]: {
+            consume: {
+                zoe: boolean;
+                board: boolean;
+                chainTimerService: boolean;
+                priceAuthority: boolean;
+                chainStorage: boolean;
+                economicCommitteeCreatorFacet: boolean;
+                auctioneerKit: boolean;
+            };
+            produce: {
+                newAuctioneerKit: boolean;
+            };
+            instance: {
+                consume: {
+                    reserve: boolean;
+                };
+            };
+            installation: {
+                consume: {
+                    auctioneer: boolean;
+                    contractGovernor: boolean;
+                };
+            };
+            issuer: {
+                consume: {
+                    IST: boolean;
+                };
+            };
+        };
+    };
+}>;
+import { Stable } from '@agoric/internal/src/tokens.js';
+//# sourceMappingURL=add-auction.d.ts.map

package/src/proposals/add-auction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-auction.d.ts","sourceRoot":"","sources":["add-auction.js"],"names":[],"mappings":"AASO,8bADK,OAAO,qBAAqB,EAAE,sBAAsB,iBA0I/D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BG;AAGI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAEN;uBAjLsB,gCAAgC"}