@agoric/inter-protocol 0.13.2-dev-8f9e16b.0 → 0.13.2-dev-8ed2bf6.0

package/src/vaultFactory/vaultDirector.js

@@ -16,8 +16,10 @@ import { Far } from '@endo/marshal';
 import { AmountMath, AmountShape, BrandShape, IssuerShape } from '@agoric/ertp';
 import {
   makeStoredPublisherKit,
+  makeStoredSubscriber,
   observeIteration,
   SubscriberShape,
+  vivifyDurablePublishKit,
 } from '@agoric/notifier';
 import {
   defineDurableFarClassKit,
@@ -26,7 +28,6 @@ import {
 } from '@agoric/vat-data';
 import { assertKeywordName } from '@agoric/zoe/src/cleanProposal.js';
 import { makeMakeCollectFeesInvitation } from '../collectFees.js';
-import { makeMetricsPublisherKit } from '../contractSupport.js';
 import {
   CHARGING_PERIOD_KEY,
   makeVaultParamManager,
@@ -34,17 +35,18 @@ import {
   SHORTFALL_INVITATION_KEY,
   vaultParamPattern,
 } from './params.js';
-import { makeVaultManager } from './vaultManager.js';
+import { vivifyVaultManagerKit } from './vaultManager.js';
+import { provideChildBaggage } from '../contractSupport.js';
 
 const { details: X, quote: q, Fail } = assert;
 
 /** @typedef {{
  * debtMint: ZCFMint<'nat'>,
  * directorParamManager: import('@agoric/governance/src/contractGovernance/typedParamManager').TypedParamManager<import('./params.js').VaultDirectorParams>,
+ * managerBaggages: *,
  * marshaller: ERef<Marshaller>,
- * metricsPublication: IterationObserver<MetricsNotification>
- * metricsSubscription: StoredSubscription<MetricsNotification>
  * shortfallReporter: import('../reserve/assetReserve.js').ShortfallReporter,
+ * storedMetricsSubscriber: StoredSubscriber<MetricsNotification>,
  * storageNode: ERef<StorageNode>,
  * vaultParamManagers: Store<Brand, import('./params.js').VaultParamManager>,
  * zcf: import('./vaultFactory.js').VaultFactoryZCF,
@@ -70,6 +72,8 @@ const ephemera = {};
  *
  * @typedef {Readonly<{
  * collateralTypes: Store<Brand,VaultManager>,
+ * metricsPublisher: Publisher<MetricsNotification>
+ * metricsSubscriber: Subscriber<MetricsNotification>
  * mintSeat: ZCFSeat,
  * rewardPoolSeat: ZCFSeat,
  * shortfallInvitation: Invitation,
@@ -92,7 +96,7 @@ const ephemera = {};
  *   state: State;
  * }>} MethodContext
  */
-// FIXME find a way to type 'finish' with the context (state and facets)
+// TODO find a way to type 'finish' with the context (state and facets)
 
 /**
  * @param {ERef<ZoeService>} zoe
@@ -143,6 +147,16 @@ const metricsOf = state => {
   });
 };
 
+// UNTIL https://github.com/Agoric/agoric-sdk/issues/6791
+const baggage = makeScalarBigMapStore('Vault Director baggage', {
+  durable: true,
+});
+
+const makeVaultDirectorMetricsPublishKit = vivifyDurablePublishKit(
+  baggage,
+  'Vault Director metrics',
+);
+
 /**
  * @param {Ephemera['zcf']} zcf
  * @param {Ephemera['directorParamManager']} directorParamManager
@@ -170,18 +184,23 @@ const initState = (
   // In the event they're needed they can be reconstructed from contract terms and off-chain data.
   const vaultParamManagers = makeScalarMap('vaultParamManagers');
 
-  const { metricsPublication, metricsSubscription } = makeMetricsPublisherKit(
-    storageNode,
+  const { publisher: metricsPublisher, subscriber: metricsSubscriber } =
+    makeVaultDirectorMetricsPublishKit();
+
+  const storedMetricsSubscriber = makeStoredSubscriber(
+    metricsSubscriber,
+    E(storageNode).makeChildNode('metrics'),
     marshaller,
   );
 
+  const managerBaggages = provideChildBaggage(baggage, 'Vault Manager baggage');
+
   Object.assign(ephemera, {
     debtMint,
     directorParamManager,
+    managerBaggages,
     marshaller,
-    metricsPublication,
-    // Subscription can't yet be held durably https://github.com/Agoric/agoric-sdk/issues/4567
-    metricsSubscription,
+    storedMetricsSubscriber,
     storageNode,
     vaultParamManagers,
     zcf,
@@ -190,6 +209,8 @@ const initState = (
   return {
     collateralTypes,
     managerCounter: 0,
+    metricsPublisher,
+    metricsSubscriber,
     mintSeat,
     rewardPoolSeat,
     // @ts-expect-error defined in finish()
@@ -445,7 +466,15 @@ const makeVaultDirector = defineDurableFarClassKit(
           burnDebt,
         });
 
-        const vm = makeVaultManager(
+        const { managerBaggages } = ephemera;
+        // alleged okay because used only as a diagnostic tag
+        const brandName = await E(collateralBrand).getAllegedName();
+        const makeVaultManager = managerBaggages.addChild(
+          brandName,
+          vivifyVaultManagerKit,
+        );
+
+        const { self: vm } = makeVaultManager(
           zcf,
           debtMint,
           collateralBrand,
@@ -479,9 +508,7 @@ const makeVaultDirector = defineDurableFarClassKit(
       },
       updateMetrics() {
         const { state } = this;
-        return ephemera.metricsPublication.updateState(
-          metricsOf(harden(state)),
-        );
+        return state.metricsPublisher.publish(metricsOf(harden(state)));
       },
       // XXX accessors for tests
       getRewardAllocation() {
@@ -527,7 +554,7 @@ const makeVaultDirector = defineDurableFarClassKit(
         );
       },
       getMetrics() {
-        return ephemera.metricsSubscription;
+        return ephemera.storedMetricsSubscriber;
       },
       /**
        * @deprecated use getCollateralManager and then makeVaultInvitation instead

package/src/vaultFactory/vaultHolder.js

@@ -2,119 +2,129 @@
  * @file Use-object for the owner of a vault
  */
 import { AmountShape } from '@agoric/ertp';
-import { makeStoredPublishKit, SubscriberShape } from '@agoric/notifier';
-import { defineDurableFarClassKit, M, makeKindHandle } from '@agoric/vat-data';
+import {
+  makeStoredSubscriber,
+  SubscriberShape,
+  vivifyDurablePublishKit,
+} from '@agoric/notifier';
+import { M, vivifyFarClassKit } from '@agoric/vat-data';
 import { makeEphemeraProvider } from '../contractSupport.js';
+import { UnguardedHelperI } from '../typeGuards.js';
 
 const { Fail } = assert;
 
-// XXX durable key to an ephemeral object
-// UNTIL https://github.com/Agoric/agoric-sdk/issues/4567
-let holderId = 0n;
-
 /**
- * @type {(key: bigint) => {
- * publisher: StoredPublishKit<VaultNotification>['publisher'],
- * subscriber: StoredPublishKit<VaultNotification>['subscriber'],
+ * Ephemera are the elements of state that cannot (or need not) be durable.
+ *
+ * @type {(durableSubscriber: Subscriber<VaultNotification>) => {
+ * storedSubscriber: StoredSubscriber<VaultNotification>,
  * }} */
 // @ts-expect-error not yet defined
 const provideEphemera = makeEphemeraProvider(() => ({}));
 
 /**
  * @typedef {{
- * holderId: bigint,
+ * publisher: PublishKit<VaultNotification>['publisher'],
+ * subscriber: PublishKit<VaultNotification>['subscriber'],
  * vault: Vault | null,
  * }} State
  */
 
+const HolderI = M.interface('holder', {
+  getCollateralAmount: M.call().returns(AmountShape),
+  getCurrentDebt: M.call().returns(AmountShape),
+  getNormalizedDebt: M.call().returns(AmountShape),
+  getSubscriber: M.call().returns(SubscriberShape),
+  makeAdjustBalancesInvitation: M.call().returns(M.promise()),
+  makeCloseInvitation: M.call().returns(M.promise()),
+  makeTransferInvitation: M.call().returns(M.promise()),
+});
 /**
  *
- * @param {Vault} vault
- * @param {ERef<StorageNode>} storageNode
- * @param {ERef<Marshaller>} marshaller
- * @returns {State}
+ * @param {import('@agoric/ertp').Baggage} baggage
  */
-const initState = (vault, storageNode, marshaller) => {
-  /** @type {StoredPublishKit<VaultNotification>} */
-  const { subscriber, publisher } = makeStoredPublishKit(
-    storageNode,
-    marshaller,
+export const vivifyVaultHolder = baggage => {
+  const makeVaultHolderPublishKit = vivifyDurablePublishKit(
+    baggage,
+    'Vault Holder publish kit',
   );
 
-  holderId += 1n;
-  const ephemera = provideEphemera(holderId);
-  // UNTIL https://github.com/Agoric/agoric-sdk/issues/4567
-  Object.assign(ephemera, { subscriber, publisher });
+  const makeVaultHolderKit = vivifyFarClassKit(
+    baggage,
+    'Vault Holder',
+    {
+      helper: UnguardedHelperI,
+      holder: HolderI,
+    },
+    /**
+     *
+     * @param {Vault} vault
+     * @param {ERef<StorageNode>} storageNode
+     * @param {ERef<Marshaller>} marshaller
+     * @returns {State}
+     */
+    (vault, storageNode, marshaller) => {
+      /** @type {PublishKit<VaultNotification>} */
+      const { subscriber, publisher } = makeVaultHolderPublishKit();
 
-  return { holderId, vault };
-};
+      const ephemera = provideEphemera(subscriber);
+      ephemera.storedSubscriber = makeStoredSubscriber(
+        subscriber,
+        storageNode,
+        marshaller,
+      );
 
-const helper = {
-  /**
-   * @throws if this holder no longer owns the vault
-   */
-  owned() {
-    const { vault } = this.state;
-    if (!vault) {
-      throw Fail`Using vault holder after transfer`;
-    }
-    return vault;
-  },
-  getUpdater() {
-    return provideEphemera(this.state.holderId).publisher;
-  },
-};
-
-const holder = {
-  getSubscriber() {
-    return provideEphemera(this.state.holderId).subscriber;
-  },
-  makeAdjustBalancesInvitation() {
-    return this.facets.helper.owned().makeAdjustBalancesInvitation();
-  },
-  makeCloseInvitation() {
-    return this.facets.helper.owned().makeCloseInvitation();
-  },
-  /**
-   * Starting a transfer revokes the vault holder. The associated updater will
-   * get a special notification that the vault is being transferred.
-   */
-  makeTransferInvitation() {
-    const vault = this.facets.helper.owned();
-    this.state.vault = null;
-    return vault.makeTransferInvitation();
-  },
-  // for status/debugging
-  getCollateralAmount() {
-    return this.facets.helper.owned().getCollateralAmount();
-  },
-  getCurrentDebt() {
-    return this.facets.helper.owned().getCurrentDebt();
-  },
-  getNormalizedDebt() {
-    return this.facets.helper.owned().getNormalizedDebt();
-  },
+      return { subscriber, publisher, vault };
+    },
+    {
+      helper: {
+        /**
+         * @throws if this holder no longer owns the vault
+         */
+        owned() {
+          const { vault } = this.state;
+          if (!vault) {
+            throw Fail`Using vault holder after transfer`;
+          }
+          return vault;
+        },
+        getUpdater() {
+          return this.state.publisher;
+        },
+      },
+      holder: {
+        /** @returns {StoredSubscriber<VaultNotification>} */
+        getSubscriber() {
+          const ephemera = provideEphemera(this.state.subscriber);
+          return ephemera.storedSubscriber;
+        },
+        makeAdjustBalancesInvitation() {
+          return this.facets.helper.owned().makeAdjustBalancesInvitation();
+        },
+        makeCloseInvitation() {
+          return this.facets.helper.owned().makeCloseInvitation();
+        },
+        /**
+         * Starting a transfer revokes the vault holder. The associated updater will
+         * get a special notification that the vault is being transferred.
+         */
+        makeTransferInvitation() {
+          const vault = this.facets.helper.owned();
+          this.state.vault = null;
+          return vault.makeTransferInvitation();
+        },
+        // for status/debugging
+        getCollateralAmount() {
+          return this.facets.helper.owned().getCollateralAmount();
+        },
+        getCurrentDebt() {
+          return this.facets.helper.owned().getCurrentDebt();
+        },
+        getNormalizedDebt() {
+          return this.facets.helper.owned().getNormalizedDebt();
+        },
+      },
+    },
+  );
+  return makeVaultHolderKit;
 };
-
-export const makeVaultHolder = defineDurableFarClassKit(
-  makeKindHandle('VaultHolder'),
-  {
-    helper: M.interface(
-      'helper',
-      // helper not exposed so guard not necessary
-      {},
-      { sloppy: true },
-    ),
-    holder: M.interface('holder', {
-      getCollateralAmount: M.call().returns(AmountShape),
-      getCurrentDebt: M.call().returns(AmountShape),
-      getNormalizedDebt: M.call().returns(AmountShape),
-      getSubscriber: M.call().returns(SubscriberShape),
-      makeAdjustBalancesInvitation: M.call().returns(M.promise()),
-      makeCloseInvitation: M.call().returns(M.promise()),
-      makeTransferInvitation: M.call().returns(M.promise()),
-    }),
-  },
-  initState,
-  { helper, holder },
-);

package/src/vaultFactory/vaultKit.js

@@ -1,37 +1,36 @@
 import '@agoric/zoe/exported.js';
 import { Far } from '@endo/marshal';
-import { makeVaultHolder } from './vaultHolder.js';
+import { vivifyVaultHolder } from './vaultHolder.js';
 
-/**
- * Create a kit of utilities for use of the vault.
- *
- * @param {Vault} vault
- * @param {ERef<StorageNode>} storageNode
- * @param {ERef<Marshaller>} marshaller
- * @param {Subscriber<import('./vaultManager').AssetState>} assetSubscriber
- */
-export const makeVaultKit = (
-  vault,
-  storageNode,
-  marshaller,
-  assetSubscriber,
-) => {
-  const { holder, helper } = makeVaultHolder(vault, storageNode, marshaller);
-  const vaultKit = harden({
-    publicSubscribers: {
-      // XXX should come from manager directly https://github.com/Agoric/agoric-sdk/issues/5814
-      asset: assetSubscriber,
-      vault: holder.getSubscriber(),
-    },
-    invitationMakers: Far('invitation makers', {
-      AdjustBalances: holder.makeAdjustBalancesInvitation,
-      CloseVault: holder.makeCloseInvitation,
-      TransferVault: holder.makeTransferInvitation,
-    }),
-    vault: holder,
-    vaultUpdater: helper.getUpdater(),
-  });
-  return vaultKit;
+export const vivifyVaultKit = baggage => {
+  const makeVaultHolder = vivifyVaultHolder(baggage);
+  /**
+   * Create a kit of utilities for use of the vault.
+   *
+   * @param {Vault} vault
+   * @param {ERef<StorageNode>} storageNode
+   * @param {ERef<Marshaller>} marshaller
+   * @param {Subscriber<import('./vaultManager').AssetState>} assetSubscriber
+   */
+  const makeVaultKit = (vault, storageNode, marshaller, assetSubscriber) => {
+    const { holder, helper } = makeVaultHolder(vault, storageNode, marshaller);
+    const vaultKit = harden({
+      publicSubscribers: {
+        // XXX should come from manager directly https://github.com/Agoric/agoric-sdk/issues/5814
+        asset: assetSubscriber,
+        vault: holder.getSubscriber(),
+      },
+      invitationMakers: Far('invitation makers', {
+        AdjustBalances: holder.makeAdjustBalancesInvitation,
+        CloseVault: holder.makeCloseInvitation,
+        TransferVault: holder.makeTransferInvitation,
+      }),
+      vault: holder,
+      vaultUpdater: helper.getUpdater(),
+    });
+    return vaultKit;
+  };
+  return makeVaultKit;
 };
 
-/** @typedef {(ReturnType<typeof makeVaultKit>)} VaultKit */
+/** @typedef {(ReturnType<ReturnType<typeof vivifyVaultKit>>)} VaultKit */