@agoric/inter-protocol 0.16.2-other-dev-8f8782b.0 → 0.16.2-other-dev-fbe72e7.0.fbe72e7

package/src/vaultFactory/vaultDirector.js

@@ -1,10 +1,14 @@
-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 { Fail, q } from '@endo/errors';
+import { E } from '@endo/eventual-send';
+import { Far } from '@endo/marshal';
 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 {
@@ -14,15 +18,12 @@ import {
 } from '@agoric/vat-data';
 import { assertKeywordName } from '@agoric/zoe/src/cleanProposal.js';
 import {
-  atomicRearrange,
   makeRecorderTopic,
   provideEmptySeat,
   SubscriberShape,
   TopicsRecordShape,
   unitAmount,
 } from '@agoric/zoe/src/contractSupport/index.js';
-import { E } from '@endo/eventual-send';
-import { Far } from '@endo/marshal';
 import { makeCollectFeesInvitation } from '../collectFees.js';
 import {
   setWakeupsForNextAuction,
@@ -38,51 +39,78 @@ import {
   provideAndStartVaultManagerKits,
 } from './vaultManager.js';
 
-const { Fail, quote: q } = assert;
+/**
+ * @import {MapStore} from '@agoric/store';
+ * @import {TransferPart, ZCF, ZCFMint, ZCFSeat} from '@agoric/zoe';
+ * @import {EReturn} from '@endo/far';
+ * @import {TypedPattern} from '@agoric/internal';
+ */
 
 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';
 
+// If one manager/token fails, we don't want that to block possible success for
+// others, so we .catch() and log separately.
+//
+// exported for testing
+export const makeAllManagersDo = (collateralManagers, vaultManagers) => {
+  /** @param {(vm: VaultManager) => void} fn */
+  return fn => {
+    for (const managerIndex of collateralManagers.values()) {
+      Promise.resolve(vaultManagers.get(managerIndex).self)
+        .then(vm => fn(vm))
+        .catch(e => trace('🚨ERROR: allManagersDo', e));
+    }
+  };
+};
+
 /**
- * @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 {Record<string, import('./params.js').VaultManagerParamOverrides>} managerParams
  */
 const prepareVaultDirector = (
   baggage,
@@ -95,6 +123,7 @@ const prepareVaultDirector = (
   marshaller,
   makeRecorderKit,
   makeERecorderKit,
+  managerParams,
 ) => {
   /** @type {import('../reserve/assetReserve.js').ShortfallReporter} */
   let shortfallReporter;
@@ -113,22 +142,22 @@ 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');
 
   const metricsKit = makeERecorderKit(
     metricsNode,
-    /** @type {import('@agoric/zoe/src/contractSupport/recorder.js').TypedMatcher<MetricsNotification>} */ (
-      M.any()
-    ),
+    /** @type {TypedPattern<MetricsNotification>} */ (M.any()),
   );
 
   const managersNode = E(storageNode).makeChildNode('managers');
 
-  /**
-   * @returns {MetricsNotification}
-   */
+  /** @returns {MetricsNotification} */
   const sampleMetrics = () => {
     return harden({
       collaterals: Array.from(collateralManagers.keys()),
@@ -141,6 +170,7 @@ const prepareVaultDirector = (
     const oldInvitation = baggage.has(shortfallInvitationKey)
       ? baggage.get(shortfallInvitationKey)
       : undefined;
+
     const newInvitation = await directorParamManager.getInternalParamValue(
       SHORTFALL_INVITATION_KEY,
     );
@@ -188,22 +218,22 @@ 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 }],
         [mintSeat, mintReceiver, { Minted: kept }],
       ];
       try {
-        atomicRearrange(zcf, harden(transfers));
+        zcf.atomicRearrange(harden(transfers));
       } catch (e) {
         console.error('mintAndTransfer failed to rearrange', e);
         // If the rearrange fails, burn the newly minted tokens.
@@ -250,12 +280,7 @@ const prepareVaultDirector = (
     metrics: makeRecorderTopic('Vault Factory metrics', metricsKit),
   });
 
-  const allManagersDo = fn => {
-    for (const managerIndex of collateralManagers.values()) {
-      const vm = vaultManagers.get(managerIndex).self;
-      fn(vm);
-    }
-  };
+  const allManagersDo = makeAllManagersDo(collateralManagers, vaultManagers);
 
   const makeWaker = (name, func) => {
     return Far(name, {
@@ -263,9 +288,7 @@ const prepareVaultDirector = (
     });
   };
 
-  /**
-   * @returns {State}
-   */
+  /** @returns {State} */
   const initState = () => {
     return {};
   };
@@ -275,7 +298,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 +316,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,9 +325,10 @@ const prepareVaultDirector = (
           SubscriberShape,
         ),
         getElectorateSubscription: M.call().returns(SubscriberShape),
-        getGovernedParams: M.call({ collateralBrand: BrandShape }).returns(
+        getGovernedParams: M.callWhen({ collateralBrand: BrandShape }).returns(
           M.record(),
         ),
+        getDirectorGovernedParams: M.call().returns(M.promise()),
         getInvitationAmount: M.call(M.string()).returns(AmountShape),
         getPublicTopics: M.call().returns(TopicsRecordShape),
       }),
@@ -330,9 +355,7 @@ const prepareVaultDirector = (
               }
             },
           }),
-        /**
-         * @param {string} name
-         */
+        /** @param {string} name */
         getInvitation(name) {
           return directorParamManager.getInternalParamValue(name);
         },
@@ -378,9 +401,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 +446,7 @@ const prepareVaultDirector = (
 
         makeLiquidationWaker() {
           return makeWaker('liquidationWaker', _timestamp => {
+            // XXX floating promise
             allManagersDo(vm => vm.liquidateVaults(auctioneer));
           });
         },
@@ -438,11 +461,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 +490,24 @@ 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,
+         * `getDirectorGovernedParams`
+         *
          * @param {{ collateralBrand: Brand }} selector
          */
         getGovernedParams({ collateralBrand }) {
           // TODO use named getters of TypedParamManager
           return vaultParamManagers.get(collateralBrand).getParams();
         },
-        /**
-         * @param {string} name
-         */
+        getDirectorGovernedParams() {
+          return directorParamManager.getParams();
+        },
+        /** @param {string} name */
         getInvitationAmount(name) {
           return directorParamManager.getInvitationAmount(name);
         },
@@ -498,9 +527,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;
 
@@ -521,11 +548,14 @@ const prepareVaultDirector = (
   return makeVaultDirector;
 };
 harden(prepareVaultDirector);
+/** @typedef {EReturn<EReturn<typeof prepareVaultDirector>>} VaultDirector */
 
 /**
  * Prepare the VaultDirector kind, get or make the singleton
  *
- * @type {(...pvdArgs: Parameters<typeof prepareVaultDirector>) => ReturnType<ReturnType<typeof prepareVaultDirector>>}
+ * @type {(
+ *   ...pvdArgs: Parameters<typeof prepareVaultDirector>
+ * ) => VaultDirector}
  */
 export const provideDirector = (...args) => {
   const makeVaultDirector = prepareVaultDirector(...args);

package/src/vaultFactory/vaultFactory.d.ts

@@ -0,0 +1,250 @@
+/**
+ * @typedef {ZCF<
+ *   GovernanceTerms<import('./params').VaultDirectorParams> & {
+ *     priceAuthority: ERef<PriceAuthority>;
+ *     reservePublicFacet: AssetReservePublicFacet;
+ *     timerService: import('@agoric/time').TimerService;
+ *   }
+ * >} VaultFactoryZCF
+ */
+/** @type {ContractMeta} */
+export const meta: ContractMeta;
+export function start(zcf: VaultFactoryZCF, privateArgs: {
+    feeMintAccess: FeeMintAccess;
+    initialPoserInvitation: Invitation;
+    initialShortfallInvitation: Invitation;
+    storageNode: ERef<StorageNode>;
+    marshaller: ERef<Marshaller>;
+    auctioneerInstance: Instance<(zcf: ZCF<GovernanceTerms<typeof import("../auction/params.js").auctioneerParamTypes> & {
+        timerService: import("@agoric/time").TimerService;
+        reservePublicFacet: AssetReservePublicFacet;
+        priceAuthority: PriceAuthority;
+    }>, privateArgs: {
+        initialPoserInvitation: Invitation;
+        storageNode: StorageNode;
+        marshaller: Marshaller;
+    }, baggage: Baggage) => Promise<{
+        publicFacet: globalThis.GovernedPublicFacet<{
+            getElectorate: () => import("@agoric/ertp").SetAmount<import("@endo/patterns").Key>;
+            getStartFrequency: () => RelativeTime;
+            getClockStep: () => RelativeTime;
+            getStartingRate: () => bigint;
+            getLowestRate: () => bigint;
+            getDiscountStep: () => bigint;
+            getAuctionStartDelay: () => RelativeTime;
+            getPriceLockPeriod: () => RelativeTime;
+            makeBidInvitation(collateralBrand: Brand<"nat">): Promise<Invitation<string, import("../auction/auctionBook.js").OfferSpec>>;
+            getSchedules(): {
+                liveAuctionSchedule: import("../auction/scheduler.js").Schedule | null;
+                nextAuctionSchedule: import("../auction/scheduler.js").Schedule | null;
+            };
+            getScheduleUpdates(): globalThis.Subscriber<import("../auction/scheduler.js").ScheduleNotification>;
+            getBookDataUpdates(brand: any): globalThis.Subscriber<import("../auction/auctionBook.js").BookDataNotification>;
+            getPublicTopics(brand: any): {
+                bookData: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../auction/auctionBook.js").BookDataNotification>;
+            } | {
+                schedule: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../auction/scheduler.js").ScheduleNotification>;
+            };
+            makeDepositInvitation: () => Promise<Invitation<string, {
+                goal: Amount<"nat">;
+            }>>;
+        }>;
+        creatorFacet: globalThis.GovernedCreatorFacet<{
+            addBrand(issuer: Issuer<"nat">, kwd: Keyword): Promise<void>;
+            getSchedule(): Promise<import("../auction/scheduler.js").FullSchedule>;
+        } & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+            addBrand(issuer: Issuer<"nat">, kwd: Keyword): Promise<void>;
+            getSchedule(): Promise<import("../auction/scheduler.js").FullSchedule>;
+        }>>;
+    }>>;
+    managerParams: Record<string, import("./params.js").VaultManagerParamOverrides>;
+    directorParamOverrides: [object];
+}, baggage: import("@agoric/swingset-liveslots").Baggage): Promise<{
+    creatorFacet: import("@endo/exo").Guarded<{
+        getParamMgrRetriever: () => {
+            get: (paramPath?: VaultFactoryParamPath) => import("./vaultDirector.js").VaultDirectorParamManager | import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                DebtLimit: "amount";
+                InterestRate: "ratio";
+                LiquidationPadding: "ratio";
+                LiquidationMargin: "ratio";
+                LiquidationPenalty: "ratio";
+                MintFee: "ratio";
+            }>;
+        } & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+            get: (paramPath?: VaultFactoryParamPath) => import("./vaultDirector.js").VaultDirectorParamManager | import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                DebtLimit: "amount";
+                InterestRate: "ratio";
+                LiquidationPadding: "ratio";
+                LiquidationMargin: "ratio";
+                LiquidationPenalty: "ratio";
+                MintFee: "ratio";
+            }>;
+        }>;
+        getInvitation(name: string): Promise<Invitation>;
+        getLimitedCreatorFacet(): import("@endo/exo").Guarded<{
+            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</*elided*/ any>>;
+                    }>;
+                    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</*elided*/ any>>;
+                        getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                        getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+                    }>;
+                    vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+                }>;
+                getCollateralQuote(): 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</*elided*/ any>>;
+                        }>;
+                        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</*elided*/ any>>;
+                            getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                            getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                            getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+                        }>;
+                        vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+                    }, undefined>>;
+                    getQuotes(): import("@agoric/notifier").StoredNotifier<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(): PriceQuote;
+                liquidateVaults(auctionPF: ERef<AuctioneerPublicFacet>): Promise<void>;
+            }>>;
+            makeCollectFeesInvitation(): Promise<Invitation<string>>;
+            getRewardAllocation(): Allocation;
+            makeLiquidationWaker(): {
+                wake: (timestamp: any) => any;
+            } & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                wake: (timestamp: any) => any;
+            }>;
+            makeReschedulerWaker(): {
+                wake: (timestamp: any) => any;
+            } & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                wake: (timestamp: any) => any;
+            }>;
+            makePriceLockWaker(): {
+                wake: (timestamp: any) => any;
+            } & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                wake: (timestamp: any) => any;
+            }>;
+            setShortfallReporter(newInvitation: any): Promise<void>;
+        }>;
+        getGovernedApis(): ERef<GovernedApis>;
+        getGovernedApiNames(): never[];
+        setOfferFilter: (strings: any) => Promise<void>;
+    }>;
+    publicFacet: import("@endo/exo").Guarded<{
+        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</*elided*/ any>>;
+                }>;
+                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</*elided*/ any>>;
+                    getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                    getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                    getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+                }>;
+                vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+            }, undefined>>;
+            getQuotes(): import("@agoric/notifier").StoredNotifier<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>;
+        getSubscription({ collateralBrand }: {
+            collateralBrand: Brand;
+        }): globalThis.StoredSubscription<globalThis.GovernanceSubscriptionState>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./vaultDirector.js").MetricsNotification>;
+        };
+        getElectorateSubscription(): globalThis.StoredSubscription<globalThis.GovernanceSubscriptionState>;
+        getGovernedParams({ collateralBrand }: {
+            collateralBrand: Brand;
+        }): globalThis.ERef<globalThis.ParamStateRecord>;
+        getDirectorGovernedParams(): globalThis.ERef<globalThis.ParamStateRecord>;
+        getInvitationAmount(name: string): import("@agoric/ertp").SetAmount<import("@agoric/zoe").InvitationDetails>;
+    }>;
+}>;
+export type VaultFactoryZCF = ZCF<GovernanceTerms<import("./params").VaultDirectorParams> & {
+    priceAuthority: ERef<PriceAuthority>;
+    reservePublicFacet: AssetReservePublicFacet;
+    timerService: import("@agoric/time").TimerService;
+}>;
+export type VaultFactoryContract = ContractOf<typeof start>;
+import type { ContractMeta } from '@agoric/zoe';
+import type { FeeMintAccess } from '@agoric/zoe';
+import type { Invitation } from '@agoric/zoe';
+import type { PriceAuthority } from '@agoric/zoe/tools/types.js';
+import type { ZCF } from '@agoric/zoe';
+import type { ZCFSeat } from '@agoric/zoe';
+import type { PriceQuote } from '@agoric/zoe/tools/types.js';
+import type { ContractOf } from '@agoric/zoe/src/zoeService/utils.js';
+//# sourceMappingURL=vaultFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vaultFactory.d.ts","sourceRoot":"","sources":["vaultFactory.js"],"names":[],"mappings":"AAuCA;;;;;;;;GAQG;AAEH,2BAA2B;AAC3B,mBADW,YAAY,CAerB;AAoBK,2BAhBI,eAAe,eACf;IACN,aAAa,EAAE,aAAa,CAAC;IAC7B,sBAAsB,EAAE,UAAU,CAAC;IACnC,0BAA0B,EAAE,UAAU,CAAC;IACvC,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;IAC/B,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAC7B,kBAAkB,EAAE,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAwC,CAAC,CAAC;IACvE,aAAa,EAAE,MAAM,CACzB,MAAY,EACZ,OAAa,aAAa,EAAE,0BAA0B,CACjD,CAAC;IACF,sBAAsB,EAAE,CAAC,MAAM,CAAC,CAAC;CAClC,WACO,OAAO,4BAA4B,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFtD;8BAhIY,IACR,eAAe,CAAC,OAAO,UAAU,EAAE,mBAAmB,CAAC,GAAG;IACxD,cAAc,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;IACrC,kBAAkB,EAAE,uBAAuB,CAAC;IAC5C,YAAY,EAAE,OAAO,cAAc,EAAE,YAAY,CAAC;CACnD,CACF;mCA6HU,WAAW,OAAO,KAAK,CAAC;kCA3IoF,aAAa;mCAAb,aAAa;gCAAb,aAAa;oCAE1C,4BAA4B;yBAFC,aAAa;6BAAb,aAAa;gCAE1C,4BAA4B;gCAD5F,qCAAqC"}