@agoric/inter-protocol 0.16.2-dev-857e650.0 → 0.16.2-dev-fb922d3.0

package/src/vaultFactory/vaultDirector.js

@@ -44,30 +44,34 @@ const trace = makeTracer('VD', true);
 
 /**
  * @typedef {{
- * collaterals: Brand[],
- * rewardPoolAllocation: AmountKeywordRecord,
+ *   collaterals: Brand[];
+ *   rewardPoolAllocation: AmountKeywordRecord;
  * }} MetricsNotification
  *
- * @typedef {Readonly<{
- * }>} ImmutableState
+ * @typedef {Readonly<{}>} ImmutableState
  *
- * @typedef {{
- * }} MutableState
+ * @typedef {{}} MutableState
  *
  * @typedef {ImmutableState & MutableState} State
  *
  * @typedef {{
- *  burnDebt: BurnDebt,
- *  getGovernedParams: (collateralBrand: Brand) => import('./vaultManager.js').GovernedParamGetters,
- *  mintAndTransfer: MintAndTransfer,
- *  getShortfallReporter: () => Promise<import('../reserve/assetReserve.js').ShortfallReporter>,
+ *   burnDebt: BurnDebt;
+ *   getGovernedParams: (
+ *     collateralBrand: Brand,
+ *   ) => import('./vaultManager.js').GovernedParamGetters;
+ *   mintAndTransfer: MintAndTransfer;
+ *   getShortfallReporter: () => Promise<
+ *     import('../reserve/assetReserve.js').ShortfallReporter
+ *   >;
  * }} FactoryPowersFacet
  *
  * @typedef {Readonly<{
  *   state: State;
  * }>} MethodContext
  *
- * @typedef {import('@agoric/governance/src/contractGovernance/typedParamManager').TypedParamManager<import('./params.js').VaultDirectorParams>} VaultDirectorParamManager
+ * @typedef {import('@agoric/governance/src/contractGovernance/typedParamManager').TypedParamManager<
+ *     import('./params.js').VaultDirectorParams
+ *   >} VaultDirectorParamManager
  */
 
 const shortfallInvitationKey = 'shortfallInvitation';
@@ -76,7 +80,7 @@ const shortfallInvitationKey = 'shortfallInvitation';
  * @param {import('@agoric/ertp').Baggage} baggage
  * @param {import('./vaultFactory.js').VaultFactoryZCF} zcf
  * @param {VaultDirectorParamManager} directorParamManager
- * @param {ZCFMint<"nat">} debtMint
+ * @param {ZCFMint<'nat'>} debtMint
  * @param {ERef<import('@agoric/time/src/types').TimerService>} timer
  * @param {ERef<import('../auction/auctioneer.js').AuctioneerPublicFacet>} auctioneer
  * @param {ERef<StorageNode>} storageNode
@@ -126,9 +130,7 @@ const prepareVaultDirector = (
 
   const managersNode = E(storageNode).makeChildNode('managers');
 
-  /**
-   * @returns {MetricsNotification}
-   */
+  /** @returns {MetricsNotification} */
   const sampleMetrics = () => {
     return harden({
       collaterals: Array.from(collateralManagers.keys()),
@@ -188,8 +190,8 @@ const prepareVaultDirector = (
     },
 
     /**
-     * Let the manager add rewards to the rewardPoolSeat without
-     * exposing the rewardPoolSeat to them.
+     * Let the manager add rewards to the rewardPoolSeat without exposing the
+     * rewardPoolSeat to them.
      *
      * @type {MintAndTransfer}
      */
@@ -264,9 +266,7 @@ const prepareVaultDirector = (
     });
   };
 
-  /**
-   * @returns {State}
-   */
+  /** @returns {State} */
   const initState = () => {
     return {};
   };
@@ -276,7 +276,7 @@ const prepareVaultDirector = (
    *
    * @param {import('./vaultFactory.js').VaultFactoryZCF} zcf
    * @param {VaultDirectorParamManager} directorParamManager
-   * @param {ZCFMint<"nat">} debtMint
+   * @param {ZCFMint<'nat'>} debtMint
    */
   const makeVaultDirector = prepareExoClassKit(
     baggage,
@@ -331,9 +331,7 @@ const prepareVaultDirector = (
               }
             },
           }),
-        /**
-         * @param {string} name
-         */
+        /** @param {string} name */
         getInvitation(name) {
           return directorParamManager.getInternalParamValue(name);
         },
@@ -442,9 +440,7 @@ const prepareVaultDirector = (
         },
       },
       public: {
-        /**
-         * @param {Brand} brandIn
-         */
+        /** @param {Brand} brandIn */
         getCollateralManager(brandIn) {
           collateralManagers.has(brandIn) ||
             Fail`Not a supported collateral type ${brandIn}`;
@@ -465,22 +461,16 @@ const prepareVaultDirector = (
         getPublicTopics() {
           return topics;
         },
-        /**
-         * subscription for the paramManager for the vaultFactory's electorate
-         */
+        /** subscription for the paramManager for the vaultFactory's electorate */
         getElectorateSubscription() {
           return directorParamManager.getSubscription();
         },
-        /**
-         * @param {{ collateralBrand: Brand }} selector
-         */
+        /** @param {{ collateralBrand: Brand }} selector */
         getGovernedParams({ collateralBrand }) {
           // TODO use named getters of TypedParamManager
           return vaultParamManagers.get(collateralBrand).getParams();
         },
-        /**
-         * @param {string} name
-         */
+        /** @param {string} name */
         getInvitationAmount(name) {
           return directorParamManager.getInvitationAmount(name);
         },
@@ -500,9 +490,7 @@ const prepareVaultDirector = (
             rescheduleWaker,
           );
         },
-        /**
-         * Start non-durable processes (or restart if needed after vat restart)
-         */
+        /** Start non-durable processes (or restart if needed after vat restart) */
         async start() {
           const { helper, machine } = this.facets;
 
@@ -527,7 +515,9 @@ harden(prepareVaultDirector);
 /**
  * Prepare the VaultDirector kind, get or make the singleton
  *
- * @type {(...pvdArgs: Parameters<typeof prepareVaultDirector>) => ReturnType<ReturnType<typeof prepareVaultDirector>>}
+ * @type {(
+ *   ...pvdArgs: Parameters<typeof prepareVaultDirector>
+ * ) => ReturnType<ReturnType<typeof prepareVaultDirector>>}
  */
 export const provideDirector = (...args) => {
   const makeVaultDirector = prepareVaultDirector(...args);

package/src/vaultFactory/vaultFactory.d.ts

@@ -1,10 +1,12 @@
 /**
- * @typedef {ZCF<GovernanceTerms<import('./params').VaultDirectorParams> & {
- *   auctioneerPublicFacet: import('../auction/auctioneer.js').AuctioneerPublicFacet,
- *   priceAuthority: ERef<PriceAuthority>,
- *   reservePublicFacet: AssetReservePublicFacet,
- *   timerService: import('@agoric/time/src/types').TimerService,
- * }>} VaultFactoryZCF
+ * @typedef {ZCF<
+ *   GovernanceTerms<import('./params').VaultDirectorParams> & {
+ *     auctioneerPublicFacet: import('../auction/auctioneer.js').AuctioneerPublicFacet;
+ *     priceAuthority: ERef<PriceAuthority>;
+ *     reservePublicFacet: AssetReservePublicFacet;
+ *     timerService: import('@agoric/time/src/types').TimerService;
+ *   }
+ * >} VaultFactoryZCF
  */
 export const privateArgsShape: import("@endo/patterns").Matcher;
 export function prepare(zcf: VaultFactoryZCF, privateArgs: {

package/src/vaultFactory/vaultFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vaultFactory.d.ts","sourceRoot":"","sources":["vaultFactory.js"],"names":[],"mappings":"AAmCA;;;;;;;GAOG;AAEH,gEAWE;AAcK,6BAVI,eAAe;mBAEN,aAAa;4BACJ,UAAU;gCACN,UAAU;iBACzB,KAAK,WAAW,CAAC;gBAClB,KAAK,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFhC;8BA9GY,IAAI,gBAAgB,OAAO,UAAU,EAAE,mBAAmB,CAAC,GAAG;IAC1E,qBAAyB,EAAE,OAAO,0BAA0B,EAAE,qBAAqB,CAAC;IACpF,cAAkB,EAAE,KAAK,cAAc,CAAC,CAAC;IACzC,kBAAsB,EAAE,uBAAuB,CAAC;IAChD,YAAgB,EAAE,OAAO,wBAAwB,EAAE,YAAY,CAAC;CAC7D,CAAC;mCA2GS,WAAW,cAAc,CAAC"}
+{"version":3,"file":"vaultFactory.d.ts","sourceRoot":"","sources":["vaultFactory.js"],"names":[],"mappings":"AAmCA;;;;;;;;;GASG;AAEH,gEAWE;AAcK,6BAVI,eAAe;mBAEN,aAAa;4BACJ,UAAU;gCACN,UAAU;iBACzB,KAAK,WAAW,CAAC;gBAClB,KAAK,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFhC;8BAhHY,IACZ,gBAAoB,OAAO,UAAU,EAAE,mBAAmB,CAAC,GAAG;IAC9D,qBAA2B,EAAE,OAAO,0BAA0B,EAAE,qBAAqB,CAAC;IACtF,cAAoB,EAAE,KAAK,cAAc,CAAC,CAAC;IAC3C,kBAAwB,EAAE,uBAAuB,CAAC;IAClD,YAAkB,EAAE,OAAO,wBAAwB,EAAE,YAAY,CAAC;CAC7D,CACF;mCA2GU,WAAW,cAAc,CAAC"}

package/src/vaultFactory/vaultFactory.js

@@ -34,12 +34,14 @@ import { provideDirector } from './vaultDirector.js';
 const trace = makeTracer('VF', true);
 
 /**
- * @typedef {ZCF<GovernanceTerms<import('./params').VaultDirectorParams> & {
- *   auctioneerPublicFacet: import('../auction/auctioneer.js').AuctioneerPublicFacet,
- *   priceAuthority: ERef<PriceAuthority>,
- *   reservePublicFacet: AssetReservePublicFacet,
- *   timerService: import('@agoric/time/src/types').TimerService,
- * }>} VaultFactoryZCF
+ * @typedef {ZCF<
+ *   GovernanceTerms<import('./params').VaultDirectorParams> & {
+ *     auctioneerPublicFacet: import('../auction/auctioneer.js').AuctioneerPublicFacet;
+ *     priceAuthority: ERef<PriceAuthority>;
+ *     reservePublicFacet: AssetReservePublicFacet;
+ *     timerService: import('@agoric/time/src/types').TimerService;
+ *   }
+ * >} VaultFactoryZCF
  */
 
 export const privateArgsShape = M.splitRecord(
@@ -59,11 +61,11 @@ harden(privateArgsShape);
 /**
  * @param {VaultFactoryZCF} zcf
  * @param {{
- *   feeMintAccess: FeeMintAccess,
- *   initialPoserInvitation: Invitation,
- *   initialShortfallInvitation: Invitation,
- *   storageNode: ERef<StorageNode>,
- *   marshaller: ERef<Marshaller>,
+ *   feeMintAccess: FeeMintAccess;
+ *   initialPoserInvitation: Invitation;
+ *   initialShortfallInvitation: Invitation;
+ *   storageNode: ERef<StorageNode>;
+ *   marshaller: ERef<Marshaller>;
  * }} privateArgs
  * @param {import('@agoric/ertp').Baggage} baggage
  */

package/src/vaultFactory/vaultHolder.d.ts

@@ -24,8 +24,8 @@ export function prepareVaultHolder(baggage: MapStore<string, unknown>, makeRecor
             makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
             makeCloseInvitation(): Promise<Invitation<R, A>>;
             /**
-             * Starting a transfer revokes the vault holder. The associated updater will
-             * get a special notification that the vault is being transferred.
+             * Starting a transfer revokes the vault holder. The associated updater
+             * will get a special notification that the vault is being transferred.
              */
             makeTransferInvitation(): Promise<Invitation<R, A>>;
             getCollateralAmount(): Amount<"nat">;
@@ -45,9 +45,7 @@ export function prepareVaultHolder(baggage: MapStore<string, unknown>, makeRecor
     getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
 }, storageNode: StorageNode) => {
     helper: {
-        /**
-         * @throws if this holder no longer owns the vault
-         */
+        /** @throws if this holder no longer owns the vault */
         owned(): {
             getVaultSeat(): ZCFSeat;
             initVaultKit(seat: ZCFSeat, storageNode: StorageNode): Promise<{
@@ -74,8 +72,8 @@ export function prepareVaultHolder(baggage: MapStore<string, unknown>, makeRecor
                     makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
                     makeCloseInvitation(): Promise<Invitation<R, A>>;
                     /**
-                     * Starting a transfer revokes the vault holder. The associated updater will
-                     * get a special notification that the vault is being transferred.
+                     * Starting a transfer revokes the vault holder. The associated updater
+                     * will get a special notification that the vault is being transferred.
                      */
                     makeTransferInvitation(): Promise<Invitation<R, A>>;
                     getCollateralAmount(): Amount<"nat">;
@@ -112,8 +110,8 @@ export function prepareVaultHolder(baggage: MapStore<string, unknown>, makeRecor
         makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
         makeCloseInvitation(): Promise<Invitation<R, A>>;
         /**
-         * Starting a transfer revokes the vault holder. The associated updater will
-         * get a special notification that the vault is being transferred.
+         * Starting a transfer revokes the vault holder. The associated updater
+         * will get a special notification that the vault is being transferred.
          */
         makeTransferInvitation(): Promise<Invitation<R, A>>;
         getCollateralAmount(): Amount<"nat">;
@@ -122,9 +120,7 @@ export function prepareVaultHolder(baggage: MapStore<string, unknown>, makeRecor
     };
 } & import("@endo/eventual-send").RemotableBrand<{}, {
     helper: {
-        /**
-         * @throws if this holder no longer owns the vault
-         */
+        /** @throws if this holder no longer owns the vault */
         owned(): {
             getVaultSeat(): ZCFSeat;
             initVaultKit(seat: ZCFSeat, storageNode: StorageNode): Promise<{
@@ -151,8 +147,8 @@ export function prepareVaultHolder(baggage: MapStore<string, unknown>, makeRecor
                     makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
                     makeCloseInvitation(): Promise<Invitation<R, A>>;
                     /**
-                     * Starting a transfer revokes the vault holder. The associated updater will
-                     * get a special notification that the vault is being transferred.
+                     * Starting a transfer revokes the vault holder. The associated updater
+                     * will get a special notification that the vault is being transferred.
                      */
                     makeTransferInvitation(): Promise<Invitation<R, A>>;
                     getCollateralAmount(): Amount<"nat">;
@@ -189,8 +185,8 @@ export function prepareVaultHolder(baggage: MapStore<string, unknown>, makeRecor
         makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
         makeCloseInvitation(): Promise<Invitation<R, A>>;
         /**
-         * Starting a transfer revokes the vault holder. The associated updater will
-         * get a special notification that the vault is being transferred.
+         * Starting a transfer revokes the vault holder. The associated updater
+         * will get a special notification that the vault is being transferred.
          */
         makeTransferInvitation(): Promise<Invitation<R, A>>;
         getCollateralAmount(): Amount<"nat">;

package/src/vaultFactory/vaultHolder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vaultHolder.d.ts","sourceRoot":"","sources":["vaultHolder.js"],"names":[],"mappings":"AAoCO,wFAFI,OAAO,6CAA6C,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;YAuExE;;;eAGG;;;;;;;;;;;;;;;;;;;QA7CH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;oBAwCH;;;uBAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;QA7CH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;oBAwCH;;;uBAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;GAoBV;oBArHY;IACZ,QAAU,EAAE,OAAO,6CAA6C,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAC;IACjG,KAAO,EAAE,KAAK,GAAG,IAAI,CAAC;CACnB"}
+{"version":3,"file":"vaultHolder.d.ts","sourceRoot":"","sources":["vaultHolder.js"],"names":[],"mappings":"AAkCO,wFAFI,OAAO,6CAA6C,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;YAoExE;;;eAGG;;;;;;;;;;;;;;;;;;;QA3CH,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;oBAwCtD;;;uBAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;QA3CH,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;oBAwCtD;;;uBAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;GAoBV;oBAlHY;IACZ,QAAY,EAAE,OAAO,6CAA6C,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAC;IACnG,KAAS,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB"}

package/src/vaultFactory/vaultHolder.js

@@ -1,6 +1,4 @@
-/**
- * @file Use-object for the owner of a vault
- */
+/** @file Use-object for the owner of a vault */
 import { AmountShape } from '@agoric/ertp';
 import { M, prepareExoClassKit } from '@agoric/vat-data';
 import { TopicsRecordShape } from '@agoric/zoe/src/contractSupport/index.js';
@@ -10,8 +8,8 @@ const { Fail } = assert;
 
 /**
  * @typedef {{
- * topicKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<VaultNotification>,
- * vault: Vault | null,
+ *   topicKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<VaultNotification>;
+ *   vault: Vault | null;
  * }} State
  */
 
@@ -25,7 +23,7 @@ const HolderI = M.interface('holder', {
   makeTransferInvitation: M.call().returns(M.promise()),
 });
 
-/** @type {{ [name: string]: [ description: string, valueShape: Pattern ] }} */
+/** @type {{ [name: string]: [description: string, valueShape: Pattern] }} */
 const PUBLIC_TOPICS = {
   vault: ['Vault holder status', M.any()],
 };
@@ -48,7 +46,6 @@ export const prepareVaultHolder = (baggage, makeRecorderKit) => {
       }),
     },
     /**
-     *
      * @param {Vault} vault
      * @param {StorageNode} storageNode
      * @returns {State}
@@ -61,9 +58,7 @@ export const prepareVaultHolder = (baggage, makeRecorderKit) => {
     },
     {
       helper: {
-        /**
-         * @throws if this holder no longer owns the vault
-         */
+        /** @throws if this holder no longer owns the vault */
         owned() {
           const { vault } = this.state;
           if (!vault) {
@@ -104,8 +99,8 @@ export const prepareVaultHolder = (baggage, makeRecorderKit) => {
           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.
+         * 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();

package/src/vaultFactory/vaultKit.d.ts

@@ -28,5 +28,5 @@ export function prepareVaultKit(baggage: MapStore<string, unknown>, makeRecorder
     };
     vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault.js").VaultNotification>;
 };
-export type VaultKit = (ReturnType<ReturnType<typeof prepareVaultKit>>);
+export type VaultKit = ReturnType<ReturnType<typeof prepareVaultKit>>;
 //# sourceMappingURL=vaultKit.d.ts.map

package/src/vaultFactory/vaultKit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vaultKit.d.ts","sourceRoot":"","sources":["vaultKit.js"],"names":[],"mappings":"AAeO,qFAFI,OAAO,6CAA6C,EAAE,eAAe,WASnE,KAAK,eACL,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBvB;uBAEa,CAAC,WAAW,WAAW,sBAAsB,CAAC,CAAC,CAAC"}
+{"version":3,"file":"vaultKit.d.ts","sourceRoot":"","sources":["vaultKit.js"],"names":[],"mappings":"AAgBO,qFAFI,OAAO,6CAA6C,EAAE,eAAe,WASnE,KAAK,eACL,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBvB;uBAEa,WAAW,WAAW,sBAAsB,CAAC,CAAC"}

package/src/vaultFactory/vaultKit.js

@@ -8,7 +8,8 @@ import { prepareVaultHolder } from './vaultHolder.js';
 const trace = makeTracer('VK', true);
 
 /**
- * Wrap the VaultHolder duration object in a record suitable for the result of an invitation.
+ * Wrap the VaultHolder duration object in a record suitable for the result of
+ * an invitation.
  *
  * @param {import('@agoric/ertp').Baggage} baggage
  * @param {import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit} makeRecorderKit
@@ -43,4 +44,4 @@ export const prepareVaultKit = (baggage, makeRecorderKit) => {
   return makeVaultKit;
 };
 
-/** @typedef {(ReturnType<ReturnType<typeof prepareVaultKit>>)} VaultKit */
+/** @typedef {ReturnType<ReturnType<typeof prepareVaultKit>>} VaultKit */