@agoric/inter-protocol 0.13.3-pismo-dev-50dc068.0 → 0.13.4-dev-800c2bb.0

package/src/vaultFactory/vaultFactory.js

@@ -1,6 +1,6 @@
-// @ts-check
+// @jessie-check
 
-import '@agoric/governance/src/exported.js';
+import '@agoric/governance/exported.js';
 import '@agoric/zoe/exported.js';
 import '@agoric/zoe/src/contracts/exported.js';
 
@@ -8,10 +8,8 @@ import '@agoric/zoe/src/contracts/exported.js';
 //
 // addVaultType is a closely held method that adds a brand new collateral type.
 // It specifies the initial exchange rate for that type. It depends on a
-// separately specified AMM to provide the ability to liquidate loans that are
-// in arrears. We could check that the AMM has sufficient liquidity, but for the
-// moment leave that to those participating in the governance process for adding
-// new collateral type to ascertain.
+// separately specified mechanism to liquidate vaults that are
+// in arrears.
 
 // This contract wants to be managed by a contractGovernor, but it isn't
 // compatible with contractGovernor, since it has a separate paramManager for
@@ -19,30 +17,45 @@ import '@agoric/zoe/src/contracts/exported.js';
 // to satisfy contractGovernor. It needs to return a creatorFacet with
 // { getParamMgrRetriever, getInvitation, getLimitedCreatorFacet }.
 
-import { assertElectorateMatches } from '@agoric/governance';
-import { makeStoredPublisherKit } from '@agoric/notifier';
-import {
-  makeVaultDirectorParamManager,
-  LIQUIDATION_INSTALL_KEY,
-  LIQUIDATION_TERMS_KEY,
-  MIN_INITIAL_DEBT_KEY,
-} from './params.js';
-import { makeVaultDirector } from './vaultDirector.js';
-import { assertKeysDefined } from '../contractSupport.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 { makeTracer, StorageNodeShape } from '@agoric/internal';
+import { makeStoredSubscription, makeSubscriptionKit } from '@agoric/notifier';
+import { M } from '@agoric/store';
+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 { FeeMintAccessShape } from '@agoric/zoe/src/typeGuards.js';
+import { InvitationShape } from '../auction/params.js';
+import { SHORTFALL_INVITATION_KEY, vaultDirectorParamTypes } from './params.js';
+import { provideDirector } from './vaultDirector.js';
+
+const trace = makeTracer('VF', true);
 
 /**
  * @typedef {ZCF<GovernanceTerms<import('./params').VaultDirectorParams> & {
- *   ammPublicFacet: AutoswapPublicFacet,
- *   liquidationInstall: Installation<import('./liquidateMinimum.js').start>,
- *   loanTimingParams: {ChargingPeriod: ParamValueTyped<'nat'>, RecordingPeriod: ParamValueTyped<'nat'>},
- *   minInitialDebt: Amount,
+ *   auctioneerPublicFacet: import('../auction/auctioneer.js').AuctioneerPublicFacet,
  *   priceAuthority: ERef<PriceAuthority>,
  *   reservePublicFacet: AssetReservePublicFacet,
- *   timerService: TimerService,
- *   shortfallInvitation: 'invitation',
+ *   timerService: import('@agoric/time/src/types').TimerService,
  * }>} VaultFactoryZCF
  */
 
+export const privateArgsShape = M.splitRecord(
+  harden({
+    marshaller: M.remotable('Marshaller'),
+    storageNode: StorageNodeShape,
+  }),
+  harden({
+    // only necessary on first invocation, not subsequent
+    feeMintAccess: FeeMintAccessShape,
+    initialPoserInvitation: InvitationShape,
+    initialShortfallInvitation: InvitationShape,
+  }),
+);
+harden(privateArgsShape);
+
 /**
  * @param {VaultFactoryZCF} zcf
  * @param {{
@@ -52,59 +65,85 @@ import { assertKeysDefined } from '../contractSupport.js';
  *   storageNode: ERef<StorageNode>,
  *   marshaller: ERef<Marshaller>,
  * }} privateArgs
+ * @param {import('@agoric/ertp').Baggage} baggage
  */
-export const start = async (zcf, privateArgs) => {
-  assertKeysDefined(privateArgs, [
-    'feeMintAccess',
-    'initialPoserInvitation',
-    'initialShortfallInvitation',
-    'storageNode',
-    'marshaller',
-  ]);
-  const { feeMintAccess, initialPoserInvitation, initialShortfallInvitation } =
-    privateArgs;
-  const debtMint = await zcf.registerFeeMint('Minted', feeMintAccess);
+export const prepare = async (zcf, privateArgs, baggage) => {
+  trace('prepare start', privateArgs, [...baggage.keys()]);
+  const {
+    initialPoserInvitation,
+    initialShortfallInvitation,
+    marshaller,
+    storageNode,
+  } = privateArgs;
+
+  trace('awaiting debtMint');
+  const { debtMint } = await provideAll(baggage, {
+    debtMint: () => zcf.registerFeeMint('Minted', privateArgs.feeMintAccess),
+  });
+
   zcf.setTestJig(() => ({
     mintedIssuerRecord: debtMint.getIssuerRecord(),
   }));
 
-  const {
-    [LIQUIDATION_INSTALL_KEY]: { value: liqInstall },
-    [LIQUIDATION_TERMS_KEY]: { value: liqTerms },
-    [MIN_INITIAL_DEBT_KEY]: { value: minInitialDebt },
-  } = zcf.getTerms().governedParams;
-  /** a powerful object; can modify the invitation */
-  const vaultDirectorParamManager = await makeVaultDirectorParamManager(
-    makeStoredPublisherKit(
-      privateArgs.storageNode,
-      privateArgs.marshaller,
-      'governance',
-    ),
-    zcf.getZoeService(),
-    initialPoserInvitation,
-    liqInstall,
-    liqTerms,
-    minInitialDebt,
-    initialShortfallInvitation,
+  const { timerService, auctioneerPublicFacet } = zcf.getTerms();
+
+  const { makeRecorderKit, makeERecorderKit } = prepareRecorderKitMakers(
+    baggage,
+    marshaller,
   );
 
-  assertElectorateMatches(
-    vaultDirectorParamManager,
-    zcf.getTerms().governedParams,
+  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(
+    governanceSubscriptionKit.subscription,
+    governanceNode,
+    marshaller,
+  );
+  /** a powerful object; can modify the invitation */
+  trace('awaiting makeParamManagerFromTerms');
+  const vaultDirectorParamManager = await makeParamManagerFromTerms(
+    {
+      publisher: governanceSubscriptionKit.publication,
+      subscriber: governanceSubscriber,
+    },
+    zcf,
+    {
+      [CONTRACT_ELECTORATE]: initialPoserInvitation,
+      [SHORTFALL_INVITATION_KEY]: initialShortfallInvitation,
+    },
+    vaultDirectorParamTypes,
   );
 
-  const factory = makeVaultDirector(
+  const director = provideDirector(
+    baggage,
     zcf,
     vaultDirectorParamManager,
     debtMint,
-    privateArgs.storageNode,
-    privateArgs.marshaller,
+    timerService,
+    auctioneerPublicFacet,
+    storageNode,
+    // XXX remove Recorder makers; remove once we excise deprecated kits for governance
+    marshaller,
+    makeRecorderKit,
+    makeERecorderKit,
   );
 
+  // cannot await because it would make remote calls during vat restart
+  director.helper.start().catch(err => {
+    console.error('💀 vaultDirector failed to start:', err);
+    zcf.shutdownWithFailure(err);
+  });
+
+  // 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 */

package/src/vaultFactory/vaultHolder.js

@@ -1,111 +1,137 @@
 /**
  * @file Use-object for the owner of a vault
  */
-// @ts-check
-import '@agoric/zoe/exported.js';
+import { AmountShape } from '@agoric/ertp';
+import { M, prepareExoClassKit } from '@agoric/vat-data';
+import {
+  SubscriberShape,
+  TopicsRecordShape,
+} from '@agoric/zoe/src/contractSupport/index.js';
+import { UnguardedHelperI } from '../typeGuards.js';
 
-import { makeStoredPublishKit } from '@agoric/notifier';
-import { defineDurableKindMulti, makeKindHandle } from '@agoric/vat-data';
-import { makeEphemeraProvider } from '../contractSupport.js';
-
-const { details: X } = 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'],
- * }} */
-// @ts-expect-error not yet defined
-const provideEphemera = makeEphemeraProvider(() => ({}));
+const { Fail } = assert;
 
 /**
  * @typedef {{
- * holderId: bigint,
+ * topicKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<VaultNotification>,
  * vault: Vault | null,
  * }} State
- * @typedef {Readonly<{
- *   state: State,
- *   facets: {
- *     helper: import('@agoric/vat-data/src/types').KindFacet<typeof helper>,
- *     self: import('@agoric/vat-data/src/types').KindFacet<typeof holder>,
- *   },
- * }>} MethodContext
- */
-
-/**
- *
- * @param {Vault} vault
- * @param {ERef<StorageNode>} storageNode
- * @param {ERef<Marshaller>} marshaller
- * @returns {State}
  */
-const initState = (vault, storageNode, marshaller) => {
-  /** @type {StoredPublishKit<VaultNotification>} */
-  const { subscriber, publisher } = makeStoredPublishKit(
-    storageNode,
-    marshaller,
-  );
 
-  holderId += 1n;
-  const ephemera = provideEphemera(holderId);
-  // UNTIL https://github.com/Agoric/agoric-sdk/issues/4567
-  Object.assign(ephemera, { subscriber, publisher });
+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),
+  getPublicTopics: M.call().returns(TopicsRecordShape),
+  makeAdjustBalancesInvitation: M.call().returns(M.promise()),
+  makeCloseInvitation: M.call().returns(M.promise()),
+  makeTransferInvitation: M.call().returns(M.promise()),
+});
 
-  return { holderId, vault };
+/** @type {{ [name: string]: [ description: string, valueShape: Pattern ] }} */
+const PUBLIC_TOPICS = {
+  vault: ['Vault holder status', M.any()],
 };
 
-const helper = {
-  /**
-   * @param {MethodContext} context
-   * @throws if this holder no longer owns the vault
-   */
-  owned: ({ state }) => {
-    const { vault } = state;
-    assert(vault, X`Using vault holder after transfer`);
-    return vault;
-  },
-  /** @param {MethodContext} context */
-  getUpdater: ({ state }) => provideEphemera(state.holderId).publisher,
-};
+/**
+ * @param {import('@agoric/ertp').Baggage} baggage
+ * @param {import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit} makeRecorderKit
+ */
+export const prepareVaultHolder = (baggage, makeRecorderKit) => {
+  const makeVaultHolderKit = prepareExoClassKit(
+    baggage,
+    'Vault Holder',
+    {
+      helper: UnguardedHelperI,
+      holder: HolderI,
+      invitationMakers: M.interface('invitationMakers', {
+        AdjustBalances: M.call().returns(M.promise()),
+        CloseVault: M.call().returns(M.promise()),
+        TransferVault: M.call().returns(M.promise()),
+      }),
+    },
+    /**
+     *
+     * @param {Vault} vault
+     * @param {StorageNode} storageNode
+     * @returns {State}
+     */
+    (vault, storageNode) => {
+      // must be the fully synchronous maker because the kit is held in durable state
+      const topicKit = makeRecorderKit(storageNode, PUBLIC_TOPICS.vault[1]);
 
-const holder = {
-  /** @param {MethodContext} context */
-  getSubscriber: ({ state }) => provideEphemera(state.holderId).subscriber,
-  /** @param {MethodContext} context */
-  makeAdjustBalancesInvitation: ({ facets }) =>
-    facets.helper.owned().makeAdjustBalancesInvitation(),
-  /** @param {MethodContext} context */
-  makeCloseInvitation: ({ facets }) =>
-    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.
-   *
-   * @param {MethodContext} context
-   */
-  makeTransferInvitation: ({ state, facets }) => {
-    const vault = facets.helper.owned();
-    state.vault = null;
-    return vault.makeTransferInvitation();
-  },
-  // for status/debugging
-  /** @param {MethodContext} context */
-  getCollateralAmount: ({ facets }) =>
-    facets.helper.owned().getCollateralAmount(),
-  /** @param {MethodContext} context */
-  getCurrentDebt: ({ facets }) => facets.helper.owned().getCurrentDebt(),
-  /** @param {MethodContext} context */
-  getNormalizedDebt: ({ facets }) => facets.helper.owned().getNormalizedDebt(),
+      return { topicKit, 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.topicKit.recorder;
+        },
+      },
+      invitationMakers: {
+        AdjustBalances() {
+          return this.facets.holder.makeAdjustBalancesInvitation();
+        },
+        CloseVault() {
+          return this.facets.holder.makeCloseInvitation();
+        },
+        TransferVault() {
+          return this.facets.holder.makeTransferInvitation();
+        },
+      },
+      holder: {
+        /** @deprecated use getPublicTopics */
+        getSubscriber() {
+          return this.state.topicKit.subscriber;
+        },
+        getPublicTopics() {
+          const { topicKit } = this.state;
+          return harden({
+            vault: {
+              description: PUBLIC_TOPICS.vault[0],
+              subscriber: topicKit.subscriber,
+              storagePath: topicKit.recorder.getStoragePath(),
+            },
+          });
+        },
+        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;
 };
-
-const behavior = { helper, holder };
-
-export const makeVaultHolder = defineDurableKindMulti(
-  makeKindHandle('VaultHolder'),
-  initState,
-  behavior,
-);

package/src/vaultFactory/vaultKit.js

@@ -1,38 +1,46 @@
-// @ts-check
+// @jessie-check
+
 import '@agoric/zoe/exported.js';
-import { Far } from '@endo/marshal';
-import { makeVaultHolder } from './vaultHolder.js';
+
+import { makeTracer } from '@agoric/internal';
+import { prepareVaultHolder } from './vaultHolder.js';
+
+const trace = makeTracer('VK', true);
 
 /**
- * Create a kit of utilities for use of the vault.
+ * Wrap the VaultHolder duration object in a record suitable for the result of an invitation.
  *
- * @param {Vault} vault
- * @param {ERef<StorageNode>} storageNode
- * @param {ERef<Marshaller>} marshaller
- * @param {Subscriber<import('./vaultManager').AssetState>} assetSubscriber
+ * @param {import('@agoric/ertp').Baggage} baggage
+ * @param {import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit} makeRecorderKit
  */
-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 prepareVaultKit = (baggage, makeRecorderKit) => {
+  trace('prepareVaultKit', [...baggage.keys()]);
+
+  const makeVaultHolder = prepareVaultHolder(baggage, makeRecorderKit);
+  /**
+   * Create a kit of utilities for use of the vault.
+   *
+   * @param {Vault} vault
+   * @param {StorageNode} storageNode
+   */
+  const makeVaultKit = (vault, storageNode) => {
+    trace('prepareVaultKit makeVaultKit');
+    const { holder, helper, invitationMakers } = makeVaultHolder(
+      vault,
+      storageNode,
+    );
+    const holderTopics = holder.getPublicTopics();
+    const vaultKit = harden({
+      publicSubscribers: {
+        vault: holderTopics.vault,
+      },
+      invitationMakers,
+      vault: holder,
+      vaultUpdater: helper.getUpdater(),
+    });
+    return vaultKit;
+  };
+  return makeVaultKit;
 };
 
-/** @typedef {(ReturnType<typeof makeVaultKit>)} VaultKit */
+/** @typedef {(ReturnType<ReturnType<typeof prepareVaultKit>>)} VaultKit */