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

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,15 @@ 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 {MapStore, SetStore} from '@agoric/store';
+ * @import {OracleStatus} from './priceOracleKit.js'
  */
 
 /** @type {string} */
@@ -26,36 +27,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 +63,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 +100,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 +173,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 +202,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 +211,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 +429,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 +443,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 +459,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 +477,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 +491,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 +500,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 +565,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 +603,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 +732,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)

package/src/proposals/add-auction.js

@@ -0,0 +1,285 @@
+import { deeplyFulfilledObject, makeTracer } from '@agoric/internal';
+import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
+import { Stable } from '@agoric/internal/src/tokens.js';
+import { E } from '@endo/far';
+import { makeGovernedTerms as makeGovernedATerms } from '../auction/params.js';
+import { provideRetiredInstances } from './utils.js';
+
+const trace = makeTracer('NewAuction', true);
+
+/**
+ * @typedef {PromiseSpaceOf<{
+ *   auctionUpgradeNewInstance: Instance;
+ *   auctionUpgradeNewGovCreator: any;
+ *   newContractGovBundleId: string;
+ *   retiredContractInstances: MapStore<string, Instance>;
+ * }>} interlockPowers
+ */
+
+/**
+ * @param {import('./econ-behaviors.js').EconomyBootstrapPowers &
+ *   interlockPowers} powers
+ * @param {{
+ *   options: {
+ *     contractGovernorRef: { bundleID: string };
+ *     contractGovernorInstallation: Installation;
+ *   };
+ * }} options
+ */
+export const addAuction = async (
+  {
+    consume: {
+      agoricNamesAdmin,
+      auctioneerKit: legacyKitP,
+      board,
+      chainStorage,
+      chainTimerService,
+      economicCommitteeCreatorFacet: electorateCreatorFacet,
+      governedContractKits: governedContractKitsP,
+      priceAuthority8400,
+      retiredContractInstances: retiredContractInstancesP,
+      zoe,
+    },
+    produce: {
+      auctioneerKit: produceAuctioneerKit,
+      auctionUpgradeNewInstance,
+      auctionUpgradeNewGovCreator,
+      newContractGovBundleId,
+      retiredContractInstances: produceRetiredInstances,
+    },
+    instance: {
+      consume: { reserve: reserveInstance },
+      produce: { auctioneer: auctionInstance },
+    },
+    installation: {
+      consume: { auctioneer: auctioneerInstallationP },
+    },
+    issuer: {
+      consume: { [Stable.symbol]: stableIssuerP },
+    },
+  },
+  {
+    options: {
+      contractGovernorRef: contractGovernorBundle,
+      contractGovernorInstallation,
+    },
+  },
+) => {
+  trace('addAuction start');
+  const STORAGE_PATH = 'auction';
+
+  const poserInvitationP = E(electorateCreatorFacet).getPoserInvitation();
+  const [
+    initialPoserInvitation,
+    electorateInvitationAmount,
+    stableIssuer,
+    legacyKit,
+    auctioneerInstallation,
+  ] = await Promise.all([
+    poserInvitationP,
+    E(E(zoe).getInvitationIssuer()).getAmountOf(poserInvitationP),
+    stableIssuerP,
+    legacyKitP,
+    auctioneerInstallationP,
+  ]);
+
+  const retiredInstances = await provideRetiredInstances(
+    retiredContractInstancesP,
+    produceRetiredInstances,
+  );
+
+  const governedContractKits = await governedContractKitsP;
+  trace('has', governedContractKits.has(legacyKit.instance));
+  if (governedContractKits.has(legacyKit.instance)) {
+    // bootstrap tests start having already run this upgrade. Actual upgrades on
+    // mainNet or testnets should start with the promiseSpace post upgrade-17,
+    // which doesn't have this entry in the map.
+    trace(
+      '⚠️ WARNING: not expected during chain upgrade.  It IS normal during bootstrap tests',
+    );
+  } else {
+    // @ts-expect-error The original auctioneerKit had everything it needs
+    governedContractKits.init(legacyKit.instance, legacyKit);
+  }
+
+  // save the auctioneer instance so we can manage it later
+  const boardID = await E(board).getId(legacyKit.instance);
+  const identifier = `auctioneer-${boardID}`;
+  retiredInstances.init(identifier, legacyKit.instance);
+
+  // Each field has an extra layer of type +  value:
+  // AuctionStartDelay: { type: 'relativeTime', value: { relValue: 2n, timerBrand: Object [Alleged: timerBrand] {} } }
+  /** @type {any} */
+  const paramValues = await E(legacyKit.publicFacet).getGovernedParams();
+  const params = harden({
+    StartFrequency: paramValues.StartFrequency.value,
+    ClockStep: paramValues.ClockStep.value,
+    StartingRate: paramValues.StartingRate.value,
+    LowestRate: paramValues.LowestRate.value,
+    DiscountStep: paramValues.DiscountStep.value,
+    AuctionStartDelay: paramValues.AuctionStartDelay.value,
+    PriceLockPeriod: paramValues.PriceLockPeriod.value,
+  });
+  const timerBrand = await E(chainTimerService).getTimerBrand();
+
+  const storageNode = await makeStorageNodeChild(chainStorage, STORAGE_PATH);
+  const marshaller = await E(board).getReadonlyMarshaller();
+
+  const reservePublicFacet = await E(zoe).getPublicFacet(reserveInstance);
+
+  const auctionTerms = makeGovernedATerms(
+    { storageNode, marshaller },
+    chainTimerService,
+    priceAuthority8400,
+    reservePublicFacet,
+    {
+      ...params,
+      ElectorateInvitationAmount: electorateInvitationAmount,
+      TimerBrand: timerBrand,
+    },
+  );
+
+  const governorTerms = await deeplyFulfilledObject(
+    harden({
+      timer: chainTimerService,
+      governedContractInstallation: auctioneerInstallation,
+      governed: {
+        terms: auctionTerms,
+        issuerKeywordRecord: { Bid: stableIssuer },
+        storageNode,
+        marshaller,
+        label: 'auctioneer',
+      },
+    }),
+  );
+
+  const bundleIdFromZoe = await E(zoe).getBundleIDFromInstallation(
+    contractGovernorInstallation,
+  );
+  trace('governor bundle ID', bundleIdFromZoe, contractGovernorBundle.bundleID);
+
+  /** @type {GovernorStartedInstallationKit<typeof auctioneerInstallationP>} */
+  const governorStartResult = await E(zoe).startInstance(
+    contractGovernorInstallation,
+    undefined,
+    governorTerms,
+    harden({
+      electorateCreatorFacet,
+      governed: {
+        initialPoserInvitation,
+        storageNode,
+        marshaller,
+      },
+    }),
+    'auctioneer.governor',
+  );
+
+  const [
+    governedInstance,
+    governedCreatorFacet,
+    governedPublicFacet,
+    governedAdminFacet,
+  ] = await Promise.all([
+    E(governorStartResult.creatorFacet).getInstance(),
+    E(governorStartResult.creatorFacet).getCreatorFacet(),
+    E(governorStartResult.creatorFacet).getPublicFacet(),
+    E(governorStartResult.creatorFacet).getAdminFacet(),
+  ]);
+
+  const allIssuers = await E(zoe).getIssuers(legacyKit.instance);
+  const { Bid: _istIssuer, ...auctionIssuers } = allIssuers;
+  await Promise.all(
+    Object.keys(auctionIssuers).map(kwd =>
+      E(governedCreatorFacet).addBrand(
+        /** @type {Issuer<'nat'>} */ (auctionIssuers[kwd]),
+        kwd,
+      ),
+    ),
+  );
+
+  const kit = harden({
+    label: 'auctioneer',
+    creatorFacet: governedCreatorFacet,
+    adminFacet: governedAdminFacet,
+    publicFacet: governedPublicFacet,
+    instance: governedInstance,
+
+    governor: governorStartResult.instance,
+    governorCreatorFacet: governorStartResult.creatorFacet,
+    governorAdminFacet: governorStartResult.adminFacet,
+  });
+  produceAuctioneerKit.reset();
+  produceAuctioneerKit.resolve(kit);
+
+  auctionInstance.reset();
+  await auctionInstance.resolve(governedInstance);
+  // belt and suspenders; the above is supposed to also do this
+  await E(E(agoricNamesAdmin).lookupAdmin('instance')).update(
+    'auctioneer',
+    governedInstance,
+  );
+
+  governedContractKits.init(kit.instance, kit);
+  auctionUpgradeNewInstance.resolve(governedInstance);
+  auctionUpgradeNewGovCreator.resolve(kit.governorCreatorFacet);
+  newContractGovBundleId.resolve(contractGovernorBundle.bundleID);
+};
+
+export const ADD_AUCTION_MANIFEST = harden({
+  [addAuction.name]: {
+    consume: {
+      agoricNamesAdmin: true,
+      auctioneerKit: true,
+      board: true,
+      chainStorage: true,
+      chainTimerService: true,
+      econCharterKit: true,
+      economicCommitteeCreatorFacet: true,
+      governedContractKits: true,
+      priceAuthority8400: true,
+      retiredContractInstances: true,
+      zoe: true,
+    },
+    produce: {
+      auctioneerKit: true,
+      auctionUpgradeNewInstance: true,
+      auctionUpgradeNewGovCreator: true,
+      newContractGovBundleId: true,
+      retiredContractInstances: true,
+    },
+    instance: {
+      consume: { reserve: true },
+      produce: { auctioneer: true },
+    },
+    installation: {
+      consume: { contractGovernor: true, auctioneer: true },
+    },
+    issuer: {
+      consume: { [Stable.symbol]: true },
+    },
+  },
+});
+
+/**
+ * Add a new auction to a chain that already has one.
+ *
+ * @param {object} utils
+ * @param {any} utils.restoreRef
+ * @param {any} addAuctionOptions
+ */
+export const getManifestForAddAuction = async (
+  { restoreRef },
+  { auctioneerRef, contractGovernorRef },
+) => {
+  const contractGovernorInstallation = restoreRef(contractGovernorRef);
+  return {
+    manifest: ADD_AUCTION_MANIFEST,
+    // XXX we should be able to receive contractGovernorInstallation via
+    // installations.consume, but the received installation isn't right.
+    options: { contractGovernorRef, contractGovernorInstallation },
+    installations: {
+      auctioneer: restoreRef(auctioneerRef),
+      contractGovernor: restoreRef(contractGovernorRef),
+    },
+  };
+};