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

package/src/price/roundsManager.d.ts

@@ -0,0 +1,204 @@
+/** @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").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").SetAmount<PriceDescription>;
+            quotePayment: globalThis.Payment<"set", PriceDescription>;
+        }> | undefined) & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, (priceQuery: any) => Promise<{
+            quoteAmount: import("@agoric/ertp").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 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 = IssuerKit<"set", PriceDescription>;
+export type HeldParams = 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;
+}>;
+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":"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"}

package/src/price/roundsManager.js

@@ -1,7 +1,7 @@
-import { Fail, q } from '@agoric/assert';
+import { Fail, q } from '@endo/errors';
 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} */
@@ -26,36 +26,32 @@ const V3_NO_DATA_ERROR = 'No data present';
 /** @type {bigint} */
 export const ROUND_MAX = BigInt(2 ** 32 - 1);
 
-const trace = makeTracer('RoundsM', false);
+const trace = makeTracer('RoundsM', true);
 
-/**
- * @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,33 @@ 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 +99,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,
@@ -162,17 +172,18 @@ export const prepareRoundsManagerKit = baggage =>
         rounds,
         unitIn,
       };
+
+      const roundId = 0n;
+
       return {
         ...immutable,
         lastValueOutForUnitIn: null,
-        reportingRoundId: 0n,
+        reportingRoundId: roundId,
       };
     },
     {
       helper: {
-        /**
-         * @param {bigint} roundId
-         */
+        /** @param {bigint} roundId */
         acceptingSubmissions(roundId) {
           const { details } = this.state;
           return (
@@ -190,9 +201,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 +210,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 +428,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 +442,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 +458,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 +476,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 +490,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 +499,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 +564,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 +602,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 to be callable by oracleStatuses. Not for use by contracts to
+         * read state.
          *
          * @param {OracleStatus} status
          * @param {Timestamp} blockTimestamp
@@ -731,4 +731,50 @@ export const prepareRoundsManagerKit = baggage =>
         },
       },
     },
+    {
+      finish: ({ state }) => {
+        const { details, rounds, timerPresence } = state;
+        // Zero is treated as special as roundId and in times. It's hard to
+        // avoid on restart and in tests, so make 1 the minimum
+
+        const firstRound = 1n;
+        state.reportingRoundId = firstRound;
+        details.init(
+          firstRound,
+          harden({
+            submissions: [],
+            maxSubmissions: state.maxSubmissionCount,
+            minSubmissions: state.minSubmissionCount,
+            roundTimeout: state.timeout,
+          }),
+        );
+
+        // Cannot await in first crank. Fail if no timestamp available
+        void E.when(
+          E(timerPresence).getCurrentTimestamp(),
+          nowMaybe => {
+            const now =
+              TimeMath.compareAbs(nowMaybe, 1n) < 0
+                ? TimeMath.coerceTimestampRecord(1n, nowMaybe.timerBrand)
+                : nowMaybe;
+
+            const round = harden({
+              answer: 0n,
+              startedAt: now,
+              updatedAt: 0n,
+              answeredInRound: 0n,
+            });
+            rounds.init(firstRound, round);
+
+            // In case this is a replacement priceFeed, set roundId in vstorage.
+            void state.latestRoundPublisher.write({
+              roundId: firstRound,
+              startedAt: round.startedAt,
+              startedBy: 'uninitialized',
+            });
+          },
+          reason => Fail`need a timestamp to start roundsManager ${reason}`,
+        );
+      },
+    },
   );

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)