@agoric/inter-protocol 0.16.2-upgrade-14-dev-c8f9e7b.0 → 0.16.2-upgrade-16-fi-dev-8879538.0

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,50 @@ 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.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 +101,7 @@ const prepareVaultDirector = (
   marshaller,
   makeRecorderKit,
   makeERecorderKit,
+  managerParams,
 ) => {
   /** @type {import('../reserve/assetReserve.js').ShortfallReporter} */
   let shortfallReporter;
@@ -113,7 +120,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 +137,7 @@ const prepareVaultDirector = (
 
   const managersNode = E(storageNode).makeChildNode('managers');
 
-  /**
-   * @returns {MetricsNotification}
-   */
+  /** @returns {MetricsNotification} */
   const sampleMetrics = () => {
     return harden({
       collaterals: Array.from(collateralManagers.keys()),
@@ -141,6 +150,7 @@ const prepareVaultDirector = (
     const oldInvitation = baggage.has(shortfallInvitationKey)
       ? baggage.get(shortfallInvitationKey)
       : undefined;
+
     const newInvitation = await directorParamManager.getInternalParamValue(
       SHORTFALL_INVITATION_KEY,
     );
@@ -188,15 +198,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 +260,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 +274,7 @@ const prepareVaultDirector = (
     });
   };
 
-  /**
-   * @returns {State}
-   */
+  /** @returns {State} */
   const initState = () => {
     return {};
   };
@@ -275,7 +284,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 +302,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 +311,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 +340,7 @@ const prepareVaultDirector = (
               }
             },
           }),
-        /**
-         * @param {string} name
-         */
+        /** @param {string} name */
         getInvitation(name) {
           return directorParamManager.getInternalParamValue(name);
         },
@@ -378,9 +386,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 +431,7 @@ const prepareVaultDirector = (
 
         makeLiquidationWaker() {
           return makeWaker('liquidationWaker', _timestamp => {
+            // XXX floating promise
             allManagersDo(vm => vm.liquidateVaults(auctioneer));
           });
         },
@@ -438,11 +446,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 +475,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 +509,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 +534,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

@@ -0,0 +1,277 @@
+/**
+ * @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;
+    managerParams: Record<string, import("./params.js").VaultManagerParamOverrides>;
+}, 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";
+            }>;
+        } & import("@endo/pass-style").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<unknown, undefined>>;
+        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<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(): 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<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: globalThis.ERef<globalThis.GovernedPublicFacet<{
+                    getElectorate: () => import("@agoric/ertp/src/types.js").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: import("@agoric/ertp/src/types.js").NatAmount;
+                    }>>;
+                }>>): Promise<void>;
+            }>>;
+            makeCollectFeesInvitation(): Promise<Invitation<string, undefined>>;
+            getRewardAllocation(): Allocation;
+            makeLiquidationWaker(): {
+                wake: (timestamp: any) => any;
+            } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                wake: (timestamp: any) => any;
+            }>;
+            makeReschedulerWaker(): {
+                wake: (timestamp: any) => any;
+            } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                wake: (timestamp: any) => any;
+            }>;
+            makePriceLockWaker(): {
+                wake: (timestamp: any) => any;
+            } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                wake: (timestamp: any) => any;
+            }>;
+            setShortfallReporter(newInvitation: any): Promise<void>;
+        }>;
+        getGovernedApis(): globalThis.ERef<globalThis.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<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<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>;
+        getInvitationAmount(name: string): import("@agoric/ertp/src/types.js").SetAmount<InvitationDetails>;
+    }>;
+}>;
+export type VaultFactoryZCF = {
+    atomicRearrange: (transfers: TransferPart[]) => void;
+    reallocate: Reallocate;
+    assertUniqueKeyword: (keyword: Keyword) => void;
+    saveIssuer: <I extends globalThis.Issuer>(issuerP: ERef<I>, keyword: Keyword) => Promise<I extends globalThis.Issuer<infer K extends globalThis.AssetKind, infer M extends import("@endo/patterns").Key> ? IssuerRecord<K, M> : never>;
+    makeInvitation: <R, A = undefined>(offerHandler: OfferHandler<ERef<R>, A>, description: string, customDetails?: object, proposalShape?: Pattern) => Promise<Invitation<R, A>>;
+    shutdown: (completion: Completion) => void;
+    shutdownWithFailure: import("@agoric/swingset-vat").ShutdownWithFailure;
+    getZoeService: () => globalThis.ERef<ZoeService>;
+    getInvitationIssuer: () => globalThis.Issuer<"set">;
+    getTerms: () => StandardTerms & globalThis.GovernanceTerms<import("@agoric/governance/src/contractGovernance/typedParamManager.js").ParamTypesMapFromRecord<{
+        Electorate: {
+            type: "invitation";
+            value: import("@agoric/ertp/src/types.js").SetAmount<import("@endo/patterns").Key>;
+        };
+        MinInitialDebt: {
+            type: "amount";
+            value: import("@agoric/ertp/src/types.js").NatAmount;
+        };
+        ShortfallInvitation: {
+            type: "invitation";
+            value: import("@agoric/ertp/src/types.js").SetAmount<import("@endo/patterns").Key>;
+        };
+        ReferencedUI: {
+            type: "string";
+            value: string;
+        };
+        ChargingPeriod: {
+            type: "nat";
+            value: bigint;
+        };
+        RecordingPeriod: {
+            type: "nat";
+            value: bigint;
+        };
+    }>> & {
+        priceAuthority: globalThis.ERef<PriceAuthority>;
+        reservePublicFacet: globalThis.GovernedPublicFacet<import("@endo/exo").Guarded<{
+            makeAddCollateralInvitation(): Promise<Invitation<string, never>>;
+            getPublicTopics(): {
+                metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../reserve/assetReserveKit.js").MetricsNotification>;
+            };
+        }>>;
+        timerService: import("@agoric/time").TimerService;
+    };
+    getBrandForIssuer: <K_1 extends globalThis.AssetKind>(issuer: Issuer<K_1>) => globalThis.Brand<K_1>;
+    getIssuerForBrand: <K_1_1 extends globalThis.AssetKind>(brand: Brand<K_1_1>) => globalThis.Issuer<K_1_1>;
+    getAssetKind: GetAssetKindByBrand;
+    makeZCFMint: <K_2 extends globalThis.AssetKind = "nat">(keyword: Keyword, assetKind?: K_2 | undefined, displayInfo?: AdditionalDisplayInfo, options?: import("@agoric/ertp").IssuerOptionsRecord) => Promise<ZCFMint<K_2>>;
+    registerFeeMint: ZCFRegisterFeeMint;
+    makeEmptySeatKit: ZCFMakeEmptySeatKit;
+    setTestJig: SetTestJig;
+    stopAcceptingOffers: () => Promise<void>;
+    setOfferFilter: (strings: Array<string>) => Promise<void>;
+    getOfferFilter: () => Promise<string[]>;
+    getInstance: () => Instance;
+};
+export type VaultFactoryContract = ContractOf<typeof start>;
+import type { PriceQuote } from '@agoric/zoe/tools/types.js';
+import type { PriceAuthority } from '@agoric/zoe/tools/types.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":"AAmCA;;;;;;;;GAQG;AAEH,2BAA2B;AAC3B,mBADW,YAAY,CAerB;AAmBK,2BAfI,eAAe,eACf;IACV,aAAiB,EAAE,aAAa,CAAC;IACjC,sBAA0B,EAAE,UAAU,CAAC;IACvC,0BAA8B,EAAE,UAAU,CAAC;IAC3C,WAAe,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;IACnC,UAAc,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IACjC,kBAAsB,EAAE,QAAQ,CAAC;IACjC,aAAiB,EAAE,MAAM,CACzB,MAAY,EACZ,OAAa,aAAa,EAAE,0BAA0B,CACjD,CAAC;CACH,WACO,OAAO,4BAA4B,EAAE,OAAO;;;8BAyFy1J,qBAAqB;;;;;;;;;;;;;;;;;;;;2CAA6lC,OAAO,KAAK,CAAC,qBAAsC,OAAO,sBAAuC,uBAAuB;;mCAAm8uB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDAApqa,MAAM,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAhsO,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAAge;YAAC,iBAAiB,KAAM,CAAA;SAAE;;;;;+CAA2jB;YAAC,iBAAiB,KAAM,CAAA;SAAE;;;GAJ/zU;;iCAhJiB,YAAa,EAAE;;mCAGsB,OAAQ;uDAKlD,KAAM,CAAC,CAAC,WAAc,OAAQ;qDAmBzB,aACd,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,+DAGW,OAAQ;2BAK5B,UADI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAbW,OAAO,cAAc,EAAE,YAAY;;kEAwBnD,OAAQ,GAAC,CAAC;mEAGd,MAAO,KAAG,CAAC;;qEAGP,OAAO,cAAiB,GAAI,YACvB,gBAAmB,qBACb,YACT,OAAI,cACD,EAAE,mBAAmB;;;;;8BAMF,aAAc;;;;mCAqF7B,UAAU,CAAC,OAAO,KAAK,CAAC;gCAtIwD,4BAA4B;oCAA5B,4BAA4B"}