@agoric/inter-protocol 0.16.1 → 0.16.2-calypso-dev-84eb287.0

package/src/vaultFactory/vaultDirector.d.ts

@@ -0,0 +1,340 @@
+/**
+ * Prepare the VaultDirector kind, get or make the singleton
+ *
+ * @type {(
+ *   ...pvdArgs: Parameters<typeof prepareVaultDirector>
+ * ) => ReturnType<ReturnType<typeof prepareVaultDirector>>}
+ */
+export const provideDirector: (...pvdArgs: Parameters<typeof prepareVaultDirector>) => ReturnType<ReturnType<typeof prepareVaultDirector>>;
+export type MetricsNotification = {
+    collaterals: Brand[];
+    rewardPoolAllocation: AmountKeywordRecord;
+};
+export type ImmutableState = Readonly<{}>;
+export type MutableState = {};
+export type State = ImmutableState & MutableState;
+export type FactoryPowersFacet = {
+    burnDebt: BurnDebt;
+    getGovernedParams: (collateralBrand: Brand) => import("./vaultManager.js").GovernedParamGetters;
+    mintAndTransfer: MintAndTransfer;
+    getShortfallReporter: () => Promise<import("../reserve/assetReserve.js").ShortfallReporter>;
+};
+export type MethodContext = Readonly<{
+    state: State;
+}>;
+export type VaultDirectorParamManager = import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<import("./params.js").VaultDirectorParams>;
+/**
+ * @param {import('@agoric/swingset-liveslots').Baggage} baggage
+ * @param {import('./vaultFactory.js').VaultFactoryZCF} zcf
+ * @param {VaultDirectorParamManager} directorParamManager
+ * @param {ZCFMint<'nat'>} debtMint
+ * @param {ERef<import('@agoric/time').TimerService>} timer
+ * @param {ERef<import('../auction/auctioneer.js').AuctioneerPublicFacet>} auctioneer
+ * @param {ERef<StorageNode>} storageNode
+ * @param {ERef<Marshaller>} marshaller
+ * @param {import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit} makeRecorderKit
+ * @param {import('@agoric/zoe/src/contractSupport/recorder.js').MakeERecorderKit} makeERecorderKit
+ * @param managerParams
+ */
+declare function prepareVaultDirector(baggage: import("@agoric/swingset-liveslots").Baggage, zcf: import("./vaultFactory.js").VaultFactoryZCF, directorParamManager: VaultDirectorParamManager, debtMint: ZCFMint<"nat">, timer: ERef<import("@agoric/time").TimerService>, auctioneer: ERef<import("../auction/auctioneer.js").AuctioneerPublicFacet>, storageNode: ERef<StorageNode>, marshaller: ERef<Marshaller>, makeRecorderKit: import("@agoric/zoe/src/contractSupport/recorder.js").MakeRecorderKit, makeERecorderKit: import("@agoric/zoe/src/contractSupport/recorder.js").MakeERecorderKit, managerParams: any): () => import("@endo/exo").GuardedKit<{
+    creator: {
+        getParamMgrRetriever: () => {
+            /** @param {VaultFactoryParamPath} paramPath */
+            get: (paramPath?: VaultFactoryParamPath) => VaultDirectorParamManager | import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                DebtLimit: "amount";
+                InterestRate: "ratio";
+                LiquidationPadding: "ratio";
+                LiquidationMargin: "ratio";
+                LiquidationPenalty: "ratio";
+                MintFee: "ratio";
+            }>;
+        } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+            /** @param {VaultFactoryParamPath} paramPath */
+            get: (paramPath?: VaultFactoryParamPath) => VaultDirectorParamManager | import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                DebtLimit: "amount";
+                InterestRate: "ratio";
+                LiquidationPadding: "ratio";
+                LiquidationMargin: "ratio";
+                LiquidationPenalty: "ratio";
+                MintFee: "ratio";
+            }>;
+        }>;
+        /** @param {string} name */
+        getInvitation(name: string): Promise<Invitation<unknown, undefined>>;
+        getLimitedCreatorFacet(): import("@endo/exo").Guarded<{
+            /**
+             * @param {Issuer<'nat'>} collateralIssuer
+             * @param {Keyword} collateralKeyword
+             * @param {VaultManagerParamValues} initialParamValues
+             */
+            addVaultType(collateralIssuer: Issuer<"nat">, collateralKeyword: Keyword, initialParamValues: VaultManagerParamValues): Promise<import("@endo/exo").Guarded<{
+                getGovernedParams(): import("./vaultManager.js").GovernedParamGetters;
+                makeVaultKit(seat: ZCFSeat): Promise<{
+                    publicSubscribers: {
+                        vault: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<VaultNotification>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                    invitationMakers: import("@endo/exo").Guarded<{
+                        AdjustBalances(): Promise<Invitation<string, undefined>>;
+                        CloseVault(): Promise<Invitation<string, undefined>>;
+                        TransferVault(): Promise<Invitation<any, undefined>>;
+                    }>;
+                    vault: import("@endo/exo").Guarded<{
+                        getPublicTopics(): {
+                            vault: {
+                                description: string;
+                                subscriber: globalThis.Subscriber<VaultNotification>;
+                                storagePath: Promise<string>;
+                            };
+                        };
+                        makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+                        makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+                        makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+                        getCollateralAmount(): import("@agoric/ertp/src/types.js").NatAmount;
+                        getCurrentDebt(): import("@agoric/ertp/src/types.js").NatAmount;
+                        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+                    }>;
+                    vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+                }>;
+                getCollateralQuote(): import("@agoric/zoe/tools/types.js").PriceQuote;
+                getPublicFacet(): import("@endo/exo").Guarded<{
+                    makeVaultInvitation(): Promise<Invitation<{
+                        publicSubscribers: {
+                            vault: {
+                                description: string;
+                                subscriber: globalThis.Subscriber<VaultNotification>;
+                                storagePath: Promise<string>;
+                            };
+                        };
+                        invitationMakers: import("@endo/exo").Guarded<{
+                            AdjustBalances(): Promise<Invitation<string, undefined>>;
+                            CloseVault(): Promise<Invitation<string, undefined>>;
+                            TransferVault(): Promise<Invitation<any, undefined>>;
+                        }>;
+                        vault: import("@endo/exo").Guarded<{
+                            getPublicTopics(): {
+                                vault: {
+                                    description: string;
+                                    subscriber: globalThis.Subscriber<VaultNotification>;
+                                    storagePath: Promise<string>;
+                                };
+                            };
+                            makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+                            makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+                            makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+                            getCollateralAmount(): import("@agoric/ertp/src/types.js").NatAmount;
+                            getCurrentDebt(): import("@agoric/ertp/src/types.js").NatAmount;
+                            getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+                        }>;
+                        vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+                    }, undefined>>;
+                    getQuotes(): import("@agoric/notifier").StoredNotifier<import("@agoric/zoe/tools/types.js").PriceQuote>;
+                    getCompoundedInterest(): Ratio;
+                    getPublicTopics(): {
+                        asset: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./vaultManager.js").AssetState>;
+                        metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./vaultManager.js").MetricsNotification>;
+                    };
+                }>;
+                lockOraclePrices(): import("@agoric/zoe/tools/types.js").PriceQuote;
+                liquidateVaults(auctionPF: ERef<AuctioneerPublicFacet>): Promise<void>;
+            }>>;
+            makeCollectFeesInvitation(): Promise<Invitation<string, undefined>>;
+            getRewardAllocation(): Allocation;
+            makeLiquidationWaker(): {
+                wake: (timestamp: any) => any;
+            } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                wake: (timestamp: any) => any;
+            }>;
+            makeReschedulerWaker(): {
+                wake: (timestamp: any) => any;
+            } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                wake: (timestamp: any) => any;
+            }>;
+            makePriceLockWaker(): {
+                wake: (timestamp: any) => any;
+            } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                wake: (timestamp: any) => any;
+            }>;
+            setShortfallReporter(newInvitation: any): Promise<void>;
+        }>;
+        /** @returns {ERef<GovernedApis>} */
+        getGovernedApis(): ERef<GovernedApis>;
+        getGovernedApiNames(): never[];
+        setOfferFilter: (strings: any) => Promise<void>;
+    };
+    machine: {
+        /**
+         * @param {Issuer<'nat'>} collateralIssuer
+         * @param {Keyword} collateralKeyword
+         * @param {VaultManagerParamValues} initialParamValues
+         */
+        addVaultType(collateralIssuer: Issuer<"nat">, collateralKeyword: Keyword, initialParamValues: VaultManagerParamValues): Promise<import("@endo/exo").Guarded<{
+            getGovernedParams(): import("./vaultManager.js").GovernedParamGetters;
+            makeVaultKit(seat: ZCFSeat): Promise<{
+                publicSubscribers: {
+                    vault: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                invitationMakers: import("@endo/exo").Guarded<{
+                    AdjustBalances(): Promise<Invitation<string, undefined>>;
+                    CloseVault(): Promise<Invitation<string, undefined>>;
+                    TransferVault(): Promise<Invitation<any, undefined>>;
+                }>;
+                vault: import("@endo/exo").Guarded<{
+                    getPublicTopics(): {
+                        vault: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<VaultNotification>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                    makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+                    makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+                    makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+                    getCollateralAmount(): import("@agoric/ertp/src/types.js").NatAmount;
+                    getCurrentDebt(): import("@agoric/ertp/src/types.js").NatAmount;
+                    getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+                }>;
+                vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+            }>;
+            getCollateralQuote(): import("@agoric/zoe/tools/types.js").PriceQuote;
+            getPublicFacet(): import("@endo/exo").Guarded<{
+                makeVaultInvitation(): Promise<Invitation<{
+                    publicSubscribers: {
+                        vault: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<VaultNotification>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                    invitationMakers: import("@endo/exo").Guarded<{
+                        AdjustBalances(): Promise<Invitation<string, undefined>>;
+                        CloseVault(): Promise<Invitation<string, undefined>>;
+                        TransferVault(): Promise<Invitation<any, undefined>>;
+                    }>;
+                    vault: import("@endo/exo").Guarded<{
+                        getPublicTopics(): {
+                            vault: {
+                                description: string;
+                                subscriber: globalThis.Subscriber<VaultNotification>;
+                                storagePath: Promise<string>;
+                            };
+                        };
+                        makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+                        makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+                        makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+                        getCollateralAmount(): import("@agoric/ertp/src/types.js").NatAmount;
+                        getCurrentDebt(): import("@agoric/ertp/src/types.js").NatAmount;
+                        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+                    }>;
+                    vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+                }, undefined>>;
+                getQuotes(): import("@agoric/notifier").StoredNotifier<import("@agoric/zoe/tools/types.js").PriceQuote>;
+                getCompoundedInterest(): Ratio;
+                getPublicTopics(): {
+                    asset: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./vaultManager.js").AssetState>;
+                    metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./vaultManager.js").MetricsNotification>;
+                };
+            }>;
+            lockOraclePrices(): import("@agoric/zoe/tools/types.js").PriceQuote;
+            liquidateVaults(auctionPF: ERef<AuctioneerPublicFacet>): Promise<void>;
+        }>>;
+        makeCollectFeesInvitation(): Promise<Invitation<string, undefined>>;
+        getRewardAllocation(): Allocation;
+        makeLiquidationWaker(): {
+            wake: (timestamp: any) => any;
+        } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+            wake: (timestamp: any) => any;
+        }>;
+        makeReschedulerWaker(): {
+            wake: (timestamp: any) => any;
+        } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+            wake: (timestamp: any) => any;
+        }>;
+        makePriceLockWaker(): {
+            wake: (timestamp: any) => any;
+        } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+            wake: (timestamp: any) => any;
+        }>;
+        setShortfallReporter(newInvitation: any): Promise<void>;
+    };
+    public: {
+        /** @param {Brand} brandIn */
+        getCollateralManager(brandIn: Brand): import("@endo/exo").Guarded<{
+            makeVaultInvitation(): Promise<Invitation<{
+                publicSubscribers: {
+                    vault: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                invitationMakers: import("@endo/exo").Guarded<{
+                    AdjustBalances(): Promise<Invitation<string, undefined>>;
+                    CloseVault(): Promise<Invitation<string, undefined>>;
+                    TransferVault(): Promise<Invitation<any, undefined>>;
+                }>;
+                vault: import("@endo/exo").Guarded<{
+                    getPublicTopics(): {
+                        vault: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<VaultNotification>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                    makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+                    makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+                    makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+                    getCollateralAmount(): import("@agoric/ertp/src/types.js").NatAmount;
+                    getCurrentDebt(): import("@agoric/ertp/src/types.js").NatAmount;
+                    getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+                }>;
+                vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+            }, undefined>>;
+            getQuotes(): import("@agoric/notifier").StoredNotifier<import("@agoric/zoe/tools/types.js").PriceQuote>;
+            getCompoundedInterest(): Ratio;
+            getPublicTopics(): {
+                asset: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./vaultManager.js").AssetState>;
+                metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./vaultManager.js").MetricsNotification>;
+            };
+        }>;
+        getDebtIssuer(): globalThis.Issuer<"nat", import("@endo/patterns").Key>;
+        /**
+         * subscription for the paramManager for a particular vaultManager
+         *
+         * @param {{ collateralBrand: Brand }} selector
+         */
+        getSubscription({ collateralBrand }: {
+            collateralBrand: Brand;
+        }): globalThis.StoredSubscription<globalThis.GovernanceSubscriptionState>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<MetricsNotification>;
+        };
+        /** subscription for the paramManager for the vaultFactory's electorate */
+        getElectorateSubscription(): globalThis.StoredSubscription<globalThis.GovernanceSubscriptionState>;
+        /**
+         * Note this works only for a collateral manager. For the director use,
+         * `getElectorateSubscription`
+         *
+         * @param {{ collateralBrand: Brand }} selector
+         */
+        getGovernedParams({ collateralBrand }: {
+            collateralBrand: Brand;
+        }): globalThis.ERef<globalThis.ParamStateRecord>;
+        /** @param {string} name */
+        getInvitationAmount(name: string): import("@agoric/ertp/src/types.js").SetAmount<InvitationDetails>;
+    };
+    helper: {
+        resetWakeupsForNextAuction(): Promise<void>;
+        /** Start non-durable processes (or restart if needed after vat restart) */
+        start(): Promise<void>;
+    };
+}>;
+export {};
+//# sourceMappingURL=vaultDirector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vaultDirector.d.ts","sourceRoot":"","sources":["vaultDirector.js"],"names":[],"mappings":"AAuhBA;;;;;;GAMG;AACH,8BAJU,CACT,GAAO,OAAO,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,KAChD,UAAU,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAQzD;kCAtfW;IACZ,WAAe,EAAE,KAAK,EAAE,CAAC;IACzB,oBAAwB,EAAE,mBAAmB,CAAC;CAC3C;6BAGS,QAAQ,CAAC,EAAE,CAAC;2BAEZ,EAAE;oBAEF,cAAc,GAAG,YAAY;iCAE7B;IACZ,QAAY,EAAE,QAAQ,CAAC;IACvB,iBAAqB,EAAE,CACvB,eAAqB,EAAE,KAAK,KACnB,OAAO,mBAAmB,EAAE,oBAAoB,CAAC;IAC1D,eAAmB,EAAE,eAAe,CAAC;IACrC,oBAAwB,EAAE,MAAM,OAAO,CACvC,OAAa,4BAA4B,EAAE,iBAAiB,CACvD,CAAC;CACH;4BAGS,QAAQ,CAAC;IACrB,KAAS,EAAE,KAAK,CAAC;CACd,CAAC;wCAEQ,OAAO,gEAAgE,EAAE,iBAAiB,CACtG,OAAa,aAAa,EAAE,mBAAmB,CAC1C;AAKN;;;;;;;;;;;;GAYG;AACH,+CAZW,OAAO,4BAA4B,EAAE,OAAO,OAC5C,OAAO,mBAAmB,EAAE,eAAe,wBAC3C,yBAAyB,YACzB,OAAO,CAAC,KAAK,CAAC,SACd,IAAI,CAAC,OAAO,cAAc,EAAE,YAAY,CAAC,cACzC,IAAI,CAAC,OAAO,0BAA0B,EAAE,qBAAqB,CAAC,eAC9D,IAAI,CAAC,WAAW,CAAC,cACjB,IAAI,CAAC,UAAU,CAAC,mBAChB,OAAO,6CAA6C,EAAE,eAAe,oBACrE,OAAO,6CAA6C,EAAE,gBAAgB,oCAiIlE,WAAW;;;YA+Gd,+CAA+C;8BAAnC,qBAAqB;;;;;;;;;YAAjC,+CAA+C;8BAAnC,qBAAqB;;;;;;;;;QAarC,2BAA2B;4BAAf,MAAM;;YAmBlB;;;;eAIG;2CAHQ,MAAM,CAAC,KAAK,CAAC,qBACb,OAAO,sBACP,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAflC,oCAAoC;2BAAtB,IAAI,CAAC,YAAY,CAAC;;;;;QAYhC;;;;WAIG;uCAHQ,MAAM,CAAC,KAAK,CAAC,qBACb,OAAO,sBACP,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA4FlC,6BAA6B;sCAAjB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAUjB;;;;WAIG;6CADQ;YAAE,eAAe,EAAE,KAAK,CAAA;SAAE;;;;QAQrC,0EAA0E;;QAI1E;;;;;WAKG;+CADQ;YAAE,eAAe,EAAE,KAAK,CAAA;SAAE;QAMrC,2BAA2B;kCAAf,MAAM;;;;QAoBlB,2EAA2E;;;GAmBlF"}

package/src/vaultFactory/vaultDirector.js

@@ -1,10 +1,11 @@
-import '@agoric/zoe/exported.js';
-import '@agoric/zoe/src/contracts/exported.js';
-
-import '@agoric/governance/exported.js';
+/// <reference types="@agoric/governance/exported" />
+/// <reference types="@agoric/zoe/exported" />
 
 import { AmountMath, AmountShape, BrandShape, IssuerShape } from '@agoric/ertp';
-import { GovernorFacetShape } from '@agoric/governance/src/typeGuards.js';
+import {
+  GovernorFacetShape,
+  InvitationShape,
+} from '@agoric/governance/src/typeGuards.js';
 import { makeTracer } from '@agoric/internal';
 import { M, mustMatch } from '@agoric/store';
 import {
@@ -44,45 +45,52 @@ const trace = makeTracer('VD', true);
 
 /**
  * @typedef {{
- * collaterals: Brand[],
- * rewardPoolAllocation: AmountKeywordRecord,
+ *   collaterals: Brand[];
+ *   rewardPoolAllocation: AmountKeywordRecord;
  * }} MetricsNotification
  *
- * @typedef {Readonly<{
- * }>} ImmutableState
  *
- * @typedef {{
- * }} MutableState
+ * @typedef {Readonly<{}>} ImmutableState
+ *
+ * @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.js').TypedParamManager<
+ *     import('./params.js').VaultDirectorParams
+ *   >} VaultDirectorParamManager
  */
 
 const shortfallInvitationKey = 'shortfallInvitation';
 
 /**
- * @param {import('@agoric/ertp').Baggage} baggage
+ * @param {import('@agoric/swingset-liveslots').Baggage} baggage
  * @param {import('./vaultFactory.js').VaultFactoryZCF} zcf
  * @param {VaultDirectorParamManager} directorParamManager
- * @param {ZCFMint<"nat">} debtMint
- * @param {ERef<import('@agoric/time/src/types').TimerService>} timer
+ * @param {ZCFMint<'nat'>} debtMint
+ * @param {ERef<import('@agoric/time').TimerService>} timer
  * @param {ERef<import('../auction/auctioneer.js').AuctioneerPublicFacet>} auctioneer
  * @param {ERef<StorageNode>} storageNode
  * @param {ERef<Marshaller>} marshaller
  * @param {import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit} makeRecorderKit
  * @param {import('@agoric/zoe/src/contractSupport/recorder.js').MakeERecorderKit} makeERecorderKit
+ * @param managerParams
  */
 const prepareVaultDirector = (
   baggage,
@@ -95,6 +103,7 @@ const prepareVaultDirector = (
   marshaller,
   makeRecorderKit,
   makeERecorderKit,
+  managerParams,
 ) => {
   /** @type {import('../reserve/assetReserve.js').ShortfallReporter} */
   let shortfallReporter;
@@ -113,7 +122,11 @@ const prepareVaultDirector = (
   // 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.
   /** a powerful object; can modify parameters */
-  const vaultParamManagers = provideVaultParamManagers(baggage, marshaller);
+  const vaultParamManagers = provideVaultParamManagers(
+    baggage,
+    marshaller,
+    managerParams,
+  );
 
   const metricsNode = E(storageNode).makeChildNode('metrics');
 
@@ -126,9 +139,7 @@ const prepareVaultDirector = (
 
   const managersNode = E(storageNode).makeChildNode('managers');
 
-  /**
-   * @returns {MetricsNotification}
-   */
+  /** @returns {MetricsNotification} */
   const sampleMetrics = () => {
     return harden({
       collaterals: Array.from(collateralManagers.keys()),
@@ -141,6 +152,7 @@ const prepareVaultDirector = (
     const oldInvitation = baggage.has(shortfallInvitationKey)
       ? baggage.get(shortfallInvitationKey)
       : undefined;
+
     const newInvitation = await directorParamManager.getInternalParamValue(
       SHORTFALL_INVITATION_KEY,
     );
@@ -188,15 +200,15 @@ 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}
      */
     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[]} */
+      /** @type {TransferPart[]} */
       const transfers = [
         ...nonMintTransfers,
         [mintSeat, rewardPoolSeat, { Minted: fee }],
@@ -250,6 +262,7 @@ const prepareVaultDirector = (
     metrics: makeRecorderTopic('Vault Factory metrics', metricsKit),
   });
 
+  /** @param {(vm: VaultManager) => void} fn */
   const allManagersDo = fn => {
     for (const managerIndex of collateralManagers.values()) {
       const vm = vaultManagers.get(managerIndex).self;
@@ -263,9 +276,7 @@ const prepareVaultDirector = (
     });
   };
 
-  /**
-   * @returns {State}
-   */
+  /** @returns {State} */
   const initState = () => {
     return {};
   };
@@ -275,7 +286,7 @@ const prepareVaultDirector = (
    *
    * @param {import('./vaultFactory.js').VaultFactoryZCF} zcf
    * @param {VaultDirectorParamManager} directorParamManager
-   * @param {ZCFMint<"nat">} debtMint
+   * @param {ZCFMint<'nat'>} debtMint
    */
   const makeVaultDirector = prepareExoClassKit(
     baggage,
@@ -293,6 +304,7 @@ const prepareVaultDirector = (
         makePriceLockWaker: M.call().returns(M.remotable('TimerWaker')),
         makeLiquidationWaker: M.call().returns(M.remotable('TimerWaker')),
         makeReschedulerWaker: M.call().returns(M.remotable('TimerWaker')),
+        setShortfallReporter: M.call(InvitationShape).returns(M.promise()),
       }),
       public: M.interface('public', {
         getCollateralManager: M.call(BrandShape).returns(M.remotable()),
@@ -301,7 +313,7 @@ const prepareVaultDirector = (
           SubscriberShape,
         ),
         getElectorateSubscription: M.call().returns(SubscriberShape),
-        getGovernedParams: M.call({ collateralBrand: BrandShape }).returns(
+        getGovernedParams: M.callWhen({ collateralBrand: BrandShape }).returns(
           M.record(),
         ),
         getInvitationAmount: M.call(M.string()).returns(AmountShape),
@@ -330,9 +342,7 @@ const prepareVaultDirector = (
               }
             },
           }),
-        /**
-         * @param {string} name
-         */
+        /** @param {string} name */
         getInvitation(name) {
           return directorParamManager.getInternalParamValue(name);
         },
@@ -378,9 +388,8 @@ const prepareVaultDirector = (
           // zero-based index of the manager being made
           const managerIndex = vaultManagers.length();
           const managerId = `manager${managerIndex}`;
-          const managerStorageNode = await E(managersNode).makeChildNode(
-            managerId,
-          );
+          const managerStorageNode =
+            await E(managersNode).makeChildNode(managerId);
 
           vaultParamManagers.addParamManager(
             collateralBrand,
@@ -424,6 +433,7 @@ const prepareVaultDirector = (
 
         makeLiquidationWaker() {
           return makeWaker('liquidationWaker', _timestamp => {
+            // XXX floating promise
             allManagersDo(vm => vm.liquidateVaults(auctioneer));
           });
         },
@@ -438,11 +448,15 @@ const prepareVaultDirector = (
             allManagersDo(vm => vm.lockOraclePrices());
           });
         },
+        async setShortfallReporter(newInvitation) {
+          const zoe = zcf.getZoeService();
+          shortfallReporter = await E(
+            E(zoe).offer(newInvitation),
+          ).getOfferResult();
+        },
       },
       public: {
-        /**
-         * @param {Brand} brandIn
-         */
+        /** @param {Brand} brandIn */
         getCollateralManager(brandIn) {
           collateralManagers.has(brandIn) ||
             Fail`Not a supported collateral type ${brandIn}`;
@@ -463,22 +477,21 @@ 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();
         },
         /**
+         * Note this works only for a collateral manager. For the director use,
+         * `getElectorateSubscription`
+         *
          * @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);
         },
@@ -498,9 +511,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;
 
@@ -525,7 +536,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);