@agoric/inter-protocol 0.13.2-dev-2354e8d.0 → 0.13.2-dev-f243a2c.0

package/src/vaultFactory/vaultDirector.js

@@ -4,12 +4,12 @@ import '@agoric/zoe/src/contracts/exported.js';
 import '@agoric/governance/exported.js';
 
 import { AmountMath, AmountShape, BrandShape, IssuerShape } from '@agoric/ertp';
+import { GovernorFacetShape } from '@agoric/governance/src/typeGuards.js';
 import { makeTracer } from '@agoric/internal';
-import { makeStoredPublisherKit } from '@agoric/notifier';
-import { M, makeScalarMapStore, mustMatch } from '@agoric/store';
+import { M, mustMatch } from '@agoric/store';
 import {
-  defineDurableExoClassKit,
-  makeKindHandle,
+  prepareExoClassKit,
+  provide,
   provideDurableMapStore,
 } from '@agoric/vat-data';
 import { assertKeywordName } from '@agoric/zoe/src/cleanProposal.js';
@@ -17,25 +17,26 @@ import {
   atomicRearrange,
   getAmountIn,
   getAmountOut,
-  makeRecorderTopic,
   makeRatioFromAmounts,
-  provideChildBaggage,
+  makeRecorderTopic,
   provideEmptySeat,
-  unitAmount,
   SubscriberShape,
   TopicsRecordShape,
+  unitAmount,
 } from '@agoric/zoe/src/contractSupport/index.js';
 import { E } from '@endo/eventual-send';
 import { Far } from '@endo/marshal';
-import { GovernorFacetShape } from '@agoric/governance/src/typeGuards.js';
 import { makeCollectFeesInvitation } from '../collectFees.js';
 import { scheduleLiquidationWakeups } from './liquidation.js';
 import {
-  makeVaultParamManager,
+  provideVaultParamManagers,
   SHORTFALL_INVITATION_KEY,
   vaultParamPattern,
 } from './params.js';
-import { prepareVaultManagerKit } from './vaultManager.js';
+import {
+  prepareVaultManagerKit,
+  provideAndStartVaultManagerKits,
+} from './vaultManager.js';
 
 const { Fail, quote: q } = assert;
 
@@ -51,14 +52,13 @@ const trace = makeTracer('VD', false);
  * }>} ImmutableState
  *
  * @typedef {{
- * managerCounter: number,
  * }} MutableState
  *
  * @typedef {ImmutableState & MutableState} State
  *
  * @typedef {{
  *  burnDebt: BurnDebt,
- *  getGovernedParams: () => import('./vaultManager.js').GovernedParamGetters,
+ *  getGovernedParams: (collateralBrand: Brand) => import('./vaultManager.js').GovernedParamGetters,
  *  mintAndTransfer: MintAndTransfer,
  *  getShortfallReporter: () => Promise<import('../reserve/assetReserve.js').ShortfallReporter>,
  * }} FactoryPowersFacet
@@ -69,7 +69,6 @@ const trace = makeTracer('VD', false);
  *
  * @typedef {import('@agoric/governance/src/contractGovernance/typedParamManager').TypedParamManager<import('./params.js').VaultDirectorParams>} VaultDirectorParamManager
  */
-// TODO find a way to type 'finish' with the context (state and facets)
 
 const shortfallInvitationKey = 'shortfallInvitation';
 
@@ -97,20 +96,24 @@ export const prepareVaultDirector = (
   makeRecorderKit,
   makeERecorderKit,
 ) => {
+  /** @type {import('../reserve/assetReserve.js').ShortfallReporter} */
+  let shortfallReporter;
+
   /** For holding newly minted tokens until transferred */
   const { zcfSeat: mintSeat } = zcf.makeEmptySeatKit();
 
   const rewardPoolSeat = provideEmptySeat(zcf, baggage, 'rewardPoolSeat');
 
-  /** @type {MapStore<Brand, VaultManager>} */
-  const collateralTypes = provideDurableMapStore(baggage, 'collateralTypes');
+  /** @type {MapStore<Brand, number>} index of manager for the given collateral */
+  const collateralManagers = provideDurableMapStore(
+    baggage,
+    'collateralManagers',
+  );
 
   // Non-durable map because param managers aren't durable.
   // In the event they're needed they can be reconstructed from contract terms and off-chain data.
-  /**
-   * @type {MapStore<Brand, ReturnType<typeof makeVaultParamManager>>}
-   */
-  const vaultParamManagers = makeScalarMapStore('vaultParamManagers');
+  /** a powerful object; can modify parameters */
+  const vaultParamManagers = provideVaultParamManagers(baggage, marshaller);
 
   const metricsNode = E(storageNode).makeChildNode('metrics');
 
@@ -121,47 +124,18 @@ export const prepareVaultDirector = (
     ),
   );
 
-  // TODO helper to make all the topics at once
-  const topics = harden({
-    metrics: makeRecorderTopic('Vault Factory metrics', metricsKit),
-  });
-
-  const allManagersDo = fn => {
-    for (const vm of collateralTypes.values()) {
-      fn(vm);
-    }
-  };
-
-  const makeWaker = (name, func) => {
-    return Far(name, {
-      wake: timestamp => func(timestamp),
-    });
-  };
   const managersNode = E(storageNode).makeChildNode('managers');
 
-  const managerBaggages = provideChildBaggage(baggage, 'Vault Manager baggage');
-
-  /** @type {import('../reserve/assetReserve.js').ShortfallReporter} */
-  let shortfallReporter;
-
-  /**
-   * @returns {State}
-   */
-  const initState = () => {
-    return {
-      managerCounter: 0,
-    };
-  };
-
   /**
    * @returns {MetricsNotification}
    */
   const sampleMetrics = () => {
     return harden({
-      collaterals: Array.from(collateralTypes.keys()),
+      collaterals: Array.from(collateralManagers.keys()),
       rewardPoolAllocation: rewardPoolSeat.getCurrentAllocation(),
     });
   };
+  const updateMetrics = () => E(metricsKit.recorderP).write(sampleMetrics());
 
   const updateShortfallReporter = async () => {
     const oldInvitation = baggage.has(shortfallInvitationKey)
@@ -188,6 +162,114 @@ export const prepareVaultDirector = (
     }
   };
 
+  const factoryPowers = Far('vault factory powers', {
+    /**
+     * Get read-only params for this manager and its director. This grants all
+     * managers access to params from all managers. It's not POLA but it's a
+     * public authority and it reduces the number of distinct power objects to
+     * create.
+     *
+     * @param {Brand} brand
+     */
+    getGovernedParams: brand => {
+      const vaultParamManager = vaultParamManagers.get(brand);
+      return Far('vault manager param manager', {
+        // merge director and manager params
+        ...directorParamManager.readonly(),
+        ...vaultParamManager.readonly(),
+        // redeclare these getters as to specify the kind of the Amount
+        getMinInitialDebt: /** @type {() => Amount<'nat'>} */ (
+          directorParamManager.readonly().getMinInitialDebt
+        ),
+        getDebtLimit: /** @type {() => Amount<'nat'>} */ (
+          vaultParamManager.readonly().getDebtLimit
+        ),
+      });
+    },
+
+    /**
+     * Let the manager add rewards to the rewardPoolSeat without
+     * exposing the rewardPoolSeat to them.
+     *
+     * @type {MintAndTransfer}
+     */
+    mintAndTransfer: (mintReceiver, toMint, fee, nonMintTransfers) => {
+      const kept = AmountMath.subtract(toMint, fee);
+      debtMint.mintGains(harden({ Minted: toMint }), mintSeat);
+      /** @type {import('@agoric/zoe/src/contractSupport/atomicTransfer.js').TransferPart[]} */
+      const transfers = [
+        ...nonMintTransfers,
+        [mintSeat, rewardPoolSeat, { Minted: fee }],
+        [mintSeat, mintReceiver, { Minted: kept }],
+      ];
+      try {
+        atomicRearrange(zcf, harden(transfers));
+      } catch (e) {
+        console.error('mintAndTransfer failed to rearrange', e);
+        // If the rearrange fails, burn the newly minted tokens.
+        // Assume this won't fail because it relies on the internal mint.
+        // (Failure would imply much larger problems.)
+        debtMint.burnLosses(harden({ Minted: toMint }), mintSeat);
+        throw e;
+      }
+      void updateMetrics();
+    },
+    getShortfallReporter: async () => {
+      await updateShortfallReporter();
+      return shortfallReporter;
+    },
+    /**
+     * @param {Amount<'nat'>} toBurn
+     * @param {ZCFSeat} seat
+     */
+    burnDebt: (toBurn, seat) => {
+      debtMint.burnLosses(harden({ Minted: toBurn }), seat);
+    },
+  });
+
+  const makeVaultManagerKit = prepareVaultManagerKit(baggage, {
+    makeERecorderKit,
+    makeRecorderKit,
+    marshaller,
+    factoryPowers,
+    zcf,
+  });
+
+  const vaultManagers = provideAndStartVaultManagerKits(baggage);
+
+  /** @type {(brand: Brand) => VaultManager} */
+  const managerForCollateral = brand => {
+    const managerIndex = collateralManagers.get(brand);
+    const manager = vaultManagers.get(managerIndex).self;
+    manager || Fail`no manager ${managerIndex} for collateral ${brand}`;
+    return manager;
+  };
+
+  // TODO helper to make all the topics at once
+  const topics = harden({
+    metrics: makeRecorderTopic('Vault Factory metrics', metricsKit),
+  });
+
+  const allManagersDo = fn => {
+    for (const managerIndex of collateralManagers.values()) {
+      const vm = vaultManagers.get(managerIndex).self;
+      fn(vm);
+    }
+  };
+
+  const makeWaker = (name, func) => {
+    return Far(name, {
+      wake: timestamp => func(timestamp),
+    });
+  };
+
+  /**
+   * @returns {State}
+   */
+  const initState = () => {
+    return {};
+  };
+
   /**
    * "Director" of the vault factory, overseeing "vault managers".
    *
@@ -195,8 +277,9 @@ export const prepareVaultDirector = (
    * @param {VaultDirectorParamManager} directorParamManager
    * @param {ZCFMint<"nat">} debtMint
    */
-  const makeVaultDirector = defineDurableExoClassKit(
-    makeKindHandle('VaultDirector'),
+  const makeVaultDirector = prepareExoClassKit(
+    baggage,
+    'VaultDirector',
     {
       creator: M.interface('creator', {
         ...GovernorFacetShape,
@@ -206,7 +289,6 @@ export const prepareVaultDirector = (
           M.promise(),
         ),
         makeCollectFeesInvitation: M.call().returns(M.promise()),
-        updateMetrics: M.call().returns(M.promise()),
         getRewardAllocation: M.call().returns({ Minted: AmountShape }),
         makePriceLockWaker: M.call().returns(M.remotable('TimerWaker')),
         makeLiquidationWaker: M.call().returns(M.remotable('TimerWaker')),
@@ -228,7 +310,8 @@ export const prepareVaultDirector = (
         getPublicTopics: M.call().returns(TopicsRecordShape),
       }),
       helper: M.interface('helper', {
-        rescheduleLiquidationWakeups: M.call().returns(),
+        rescheduleLiquidationWakeups: M.call().returns(M.promise()),
+        start: M.call().returns(M.promise()),
       }),
     },
     initState,
@@ -281,7 +364,6 @@ export const prepareVaultDirector = (
           initialParamValues,
         ) {
           trace('addVaultType', collateralKeyword, initialParamValues);
-          const { state, facets } = this;
           mustMatch(collateralIssuer, M.remotable(), 'collateralIssuer');
           assertKeywordName(collateralKeyword);
           mustMatch(
@@ -292,120 +374,41 @@ export const prepareVaultDirector = (
           await zcf.saveIssuer(collateralIssuer, collateralKeyword);
           const collateralBrand = zcf.getBrandForIssuer(collateralIssuer);
           // We create only one vault per collateralType.
-          !collateralTypes.has(collateralBrand) ||
+          !collateralManagers.has(collateralBrand) ||
             Fail`Collateral brand ${q(collateralBrand)} has already been added`;
 
-          // counter to be incremented at end of addVaultType
-          const managerId = `manager${state.managerCounter}`;
+          // zero-based index of the manager being made
+          const managerIndex = vaultManagers.length();
+          const managerId = `manager${managerIndex}`;
           const managerStorageNode = await E(managersNode).makeChildNode(
             managerId,
           );
 
-          /** a powerful object; can modify parameters */
-          const vaultParamManager = makeVaultParamManager(
-            makeStoredPublisherKit(
-              managerStorageNode,
-              marshaller,
-              'governance',
-            ),
+          vaultParamManagers.addParamManager(
+            collateralBrand,
+            managerStorageNode,
             initialParamValues,
           );
-          vaultParamManagers.init(collateralBrand, vaultParamManager);
 
           const startTimeStamp = await E(timer).getCurrentTimestamp();
 
-          /**
-           * Let the manager add rewards to the rewardPoolSeat without
-           * exposing the rewardPoolSeat to them.
-           *
-           * @type {MintAndTransfer}
-           */
-          const mintAndTransfer = (
-            mintReceiver,
-            toMint,
-            fee,
-            nonMintTransfers,
-          ) => {
-            const kept = AmountMath.subtract(toMint, fee);
-            debtMint.mintGains(harden({ Minted: toMint }), mintSeat);
-            /** @type {import('@agoric/zoe/src/contractSupport/atomicTransfer.js').TransferPart[]} */
-            const transfers = [
-              ...nonMintTransfers,
-              [mintSeat, rewardPoolSeat, { Minted: fee }],
-              [mintSeat, mintReceiver, { Minted: kept }],
-            ];
-            try {
-              atomicRearrange(zcf, harden(transfers));
-            } catch (e) {
-              console.error('mintAndTransfer failed to rearrange', e);
-              // If the rearrange fails, burn the newly minted tokens.
-              // Assume this won't fail because it relies on the internal mint.
-              // (Failure would imply much larger problems.)
-              debtMint.burnLosses(harden({ Minted: toMint }), mintSeat);
-              throw e;
-            }
-            void facets.machine.updateMetrics();
-          };
-
-          /**
-           * @param {Amount<'nat'>} toBurn
-           * @param {ZCFSeat} seat
-           */
-          const burnDebt = (toBurn, seat) => {
-            debtMint.burnLosses(harden({ Minted: toBurn }), seat);
-          };
-
-          const factoryPowers = Far('vault factory powers', {
-            /**
-             * @returns read-only params for this manager and its director
-             */
-            getGovernedParams: () =>
-              Far('vault manager param manager', {
-                // merge direction and manager params
-                ...directorParamManager.readonly(),
-                ...vaultParamManager.readonly(),
-                // redeclare these getters as to specify the kind of the Amount
-                getMinInitialDebt: /** @type {() => Amount<'nat'>} */ (
-                  directorParamManager.readonly().getMinInitialDebt
-                ),
-                getDebtLimit: /** @type {() => Amount<'nat'>} */ (
-                  vaultParamManager.readonly().getDebtLimit
-                ),
-              }),
-            mintAndTransfer,
-            getShortfallReporter: async () => {
-              await updateShortfallReporter();
-              return shortfallReporter;
-            },
-            burnDebt,
-          });
-
-          // alleged okay because used only as a diagnostic tag
-          const brandName = await E(collateralBrand).getAllegedName();
           const collateralUnit = await unitAmount(collateralBrand);
 
-          const makeVaultManager = managerBaggages.addChild(
-            brandName,
-            prepareVaultManagerKit,
-            zcf,
-            marshaller,
-            makeRecorderKit,
-            makeERecorderKit,
-            {
-              debtMint,
-              collateralBrand,
-              collateralUnit,
-              descriptionScope: managerId,
-              factoryPowers,
-              startTimeStamp,
-              storageNode: managerStorageNode,
-            },
-          );
-
-          const { self: vm } = makeVaultManager();
-          collateralTypes.init(collateralBrand, vm);
-          void facets.machine.updateMetrics();
-          state.managerCounter += 1;
+          const kit = await makeVaultManagerKit({
+            debtMint,
+            collateralBrand,
+            collateralUnit,
+            descriptionScope: managerId,
+            startTimeStamp,
+            storageNode: managerStorageNode,
+          });
+          vaultManagers.add(kit);
+          vaultManagers.length() - 1 === managerIndex ||
+            Fail`mismatch VaultManagerKit count`;
+          const { self: vm } = kit;
+          vm || Fail`no vault`;
+          collateralManagers.init(collateralBrand, managerIndex);
+          void updateMetrics();
           return vm;
         },
         makeCollectFeesInvitation() {
@@ -416,9 +419,6 @@ export const prepareVaultDirector = (
             'Minted',
           );
         },
-        updateMetrics() {
-          return E(metricsKit.recorderP).write(sampleMetrics());
-        },
         // XXX accessors for tests
         getRewardAllocation() {
           return rewardPoolSeat.getCurrentAllocation();
@@ -432,7 +432,7 @@ export const prepareVaultDirector = (
         makeReschedulerWaker() {
           const { facets } = this;
           return makeWaker('reschedulerWaker', () => {
-            facets.helper.rescheduleLiquidationWakeups();
+            void facets.helper.rescheduleLiquidationWakeups();
           });
         },
         makePriceLockWaker() {
@@ -446,33 +446,36 @@ export const prepareVaultDirector = (
          * @param {Brand} brandIn
          */
         getCollateralManager(brandIn) {
-          collateralTypes.has(brandIn) ||
+          collateralManagers.has(brandIn) ||
             Fail`Not a supported collateral type ${brandIn}`;
           /** @type {VaultManager} */
-          return collateralTypes.get(brandIn).getPublicFacet();
+          return managerForCollateral(brandIn).getPublicFacet();
         },
         /**
          * @deprecated get `collaterals` list from metrics
          */
         async getCollaterals() {
-          // should be collateralTypes.map((vm, brand) => ({
+          // should be collateralManagers.map((vm, brand) => ({
           return harden(
             Promise.all(
-              [...collateralTypes.entries()].map(async ([brand, vm]) => {
-                const priceQuote = await vm.getCollateralQuote();
-                return {
-                  brand,
-                  interestRate: vm.getGovernedParams().getInterestRate(),
-                  liquidationMargin: vm
-                    .getGovernedParams()
-                    .getLiquidationMargin(),
-                  stabilityFee: vm.getGovernedParams().getMintFee(),
-                  marketPrice: makeRatioFromAmounts(
-                    getAmountOut(priceQuote),
-                    getAmountIn(priceQuote),
-                  ),
-                };
-              }),
+              [...collateralManagers.entries()].map(
+                async ([brand, managerIndex]) => {
+                  const vm = vaultManagers.get(managerIndex).self;
+                  const priceQuote = await vm.getCollateralQuote();
+                  return {
+                    brand,
+                    interestRate: vm.getGovernedParams().getInterestRate(),
+                    liquidationMargin: vm
+                      .getGovernedParams()
+                      .getLiquidationMargin(),
+                    stabilityFee: vm.getGovernedParams().getMintFee(),
+                    marketPrice: makeRatioFromAmounts(
+                      getAmountOut(priceQuote),
+                      getAmountIn(priceQuote),
+                    ),
+                  };
+                },
+              ),
             ),
           );
         },
@@ -523,7 +526,7 @@ export const prepareVaultDirector = (
           const priceLockWaker = facets.machine.makePriceLockWaker();
           const liquidationWaker = facets.machine.makeLiquidationWaker();
           const rescheduleWaker = facets.machine.makeReschedulerWaker();
-          void scheduleLiquidationWakeups(
+          return scheduleLiquidationWakeups(
             auctioneer,
             timer,
             priceLockWaker,
@@ -531,15 +534,33 @@ export const prepareVaultDirector = (
             rescheduleWaker,
           );
         },
-      },
-    },
-    {
-      finish: ({ facets }) => {
-        facets.helper.rescheduleLiquidationWakeups();
-        void updateShortfallReporter();
+        /**
+         * Start non-durable processes (or restart if needed after vat restart)
+         */
+        async start() {
+          const { helper } = this.facets;
+          helper.rescheduleLiquidationWakeups();
+          await updateShortfallReporter();
+        },
       },
     },
   );
   return makeVaultDirector;
 };
 harden(prepareVaultDirector);
+
+/**
+ * Prepare the VaultDirector kind, get or make the singleton, and call .start() to kick off processes.
+ *
+ * @type {(...pvdArgs: Parameters<typeof prepareVaultDirector>) => ReturnType<ReturnType<typeof prepareVaultDirector>>}
+ */
+export const provideAndStartDirector = (...args) => {
+  const makeVaultDirector = prepareVaultDirector(...args);
+
+  const [baggage] = args;
+
+  const director = provide(baggage, 'director', makeVaultDirector);
+  director.helper.start();
+  return director;
+};
+harden(provideAndStartDirector);

package/src/vaultFactory/vaultFactory.js

@@ -20,12 +20,15 @@ import '@agoric/zoe/src/contracts/exported.js';
 import { CONTRACT_ELECTORATE } from '@agoric/governance';
 import { makeParamManagerFromTerms } from '@agoric/governance/src/contractGovernance/typedParamManager.js';
 import { validateElectorate } from '@agoric/governance/src/contractHelper.js';
-import { assertAllDefined } from '@agoric/internal';
+import { assertAllDefined, makeTracer } from '@agoric/internal';
 import { makeStoredSubscription, makeSubscriptionKit } from '@agoric/notifier';
+import { provideAll } from '@agoric/zoe/src/contractSupport/durability.js';
 import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport/recorder.js';
 import { E } from '@endo/eventual-send';
 import { SHORTFALL_INVITATION_KEY, vaultDirectorParamTypes } from './params.js';
-import { prepareVaultDirector } from './vaultDirector.js';
+import { provideAndStartDirector } from './vaultDirector.js';
+
+const trace = makeTracer('VF', false);
 
 /**
  * @typedef {ZCF<GovernanceTerms<import('./params').VaultDirectorParams> & {
@@ -47,7 +50,8 @@ import { prepareVaultDirector } from './vaultDirector.js';
  * }} privateArgs
  * @param {import('@agoric/ertp').Baggage} baggage
  */
-export const start = async (zcf, privateArgs, baggage) => {
+export const prepare = async (zcf, privateArgs, baggage) => {
+  trace('prepare start', privateArgs, [...baggage.keys()]);
   const {
     feeMintAccess,
     initialPoserInvitation,
@@ -62,7 +66,12 @@ export const start = async (zcf, privateArgs, baggage) => {
     marshaller,
     storageNode,
   });
-  const debtMint = await zcf.registerFeeMint('Minted', feeMintAccess);
+
+  trace('awaiting debtMint');
+  const { debtMint } = await provideAll(baggage, {
+    debtMint: () => zcf.registerFeeMint('Minted', privateArgs.feeMintAccess),
+  });
+
   zcf.setTestJig(() => ({
     mintedIssuerRecord: debtMint.getIssuerRecord(),
   }));
@@ -74,7 +83,8 @@ export const start = async (zcf, privateArgs, baggage) => {
     marshaller,
   );
 
-  // XXX non-durable
+  trace('making non-durable publishers');
+  // XXX non-durable, will sever upon vat restart
   const governanceSubscriptionKit = makeSubscriptionKit();
   const governanceNode = E(storageNode).makeChildNode('governance');
   const governanceSubscriber = makeStoredSubscription(
@@ -83,6 +93,7 @@ export const start = async (zcf, privateArgs, baggage) => {
     marshaller,
   );
   /** a powerful object; can modify the invitation */
+  trace('awaiting makeParamManagerFromTerms');
   const vaultDirectorParamManager = await makeParamManagerFromTerms(
     {
       publisher: governanceSubscriptionKit.publication,
@@ -96,7 +107,7 @@ export const start = async (zcf, privateArgs, baggage) => {
     vaultDirectorParamTypes,
   );
 
-  const makeVaultDirector = prepareVaultDirector(
+  const director = provideAndStartDirector(
     baggage,
     zcf,
     vaultDirectorParamManager,
@@ -110,16 +121,14 @@ export const start = async (zcf, privateArgs, baggage) => {
     makeERecorderKit,
   );
 
-  const factory = makeVaultDirector();
-
   // validate async to wait for params to be finished
   // UNTIL https://github.com/Agoric/agoric-sdk/issues/4343
   void validateElectorate(zcf, vaultDirectorParamManager);
 
   return harden({
-    creatorFacet: factory.creator,
-    publicFacet: factory.public,
+    creatorFacet: director.creator,
+    publicFacet: director.public,
   });
 };
 
-/** @typedef {ContractOf<typeof start>} VaultFactoryContract */
+/** @typedef {ContractOf<typeof prepare>} VaultFactoryContract */