@agoric/inter-protocol 0.17.0 → 0.17.1-upgrade-23-dev-bd79330.0.bd79330

package/src/vaultFactory/vaultDirector.js

@@ -1,9 +1,3 @@
-/// <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,
@@ -24,11 +18,10 @@ import {
   TopicsRecordShape,
   unitAmount,
 } from '@agoric/zoe/src/contractSupport/index.js';
+import { Fail, q } from '@endo/errors';
+import { E } from '@endo/eventual-send';
+import { Far } from '@endo/marshal';
 import { makeCollectFeesInvitation } from '../collectFees.js';
-import {
-  setWakeupsForNextAuction,
-  watchForGovernanceChange,
-} from './liquidation.js';
 import {
   provideVaultParamManagers,
   SHORTFALL_INVITATION_KEY,
@@ -41,9 +34,30 @@ import {
 
 /**
  * @import {MapStore} from '@agoric/store';
- * @import {TransferPart, ZCF, ZCFMint, ZCFSeat} from '@agoric/zoe';
+ * @import {AmountKeywordRecord, Keyword, TransferPart, ZCF, ZCFMint, ZCFSeat} from '@agoric/zoe';
  * @import {EReturn} from '@endo/far';
- * @import {TypedPattern} from '@agoric/internal';
+ * @import {TypedPattern, ERemote, Remote} from '@agoric/internal';
+ * @import {EMarshaller} from '@agoric/internal/src/marshal/wrap-marshaller.js';
+ * @import {GovernedParamGetters} from './vaultManager.js';
+ * @import {ShortfallReporter} from '../reserve/assetReserve.js';
+ * @import {TypedParamManager} from '@agoric/governance/src/contractGovernance/typedParamManager.js';
+ * @import {VaultDirectorParams} from './params.js';
+ * @import {Baggage} from '@agoric/swingset-liveslots';
+ * @import {VaultFactoryZCF} from './vaultFactory.js';
+ * @import {TimerService} from '@agoric/time';
+ * @import {MakeRecorderKit} from '@agoric/zoe/src/contractSupport/recorder.js';
+ * @import {MakeERecorderKit} from '@agoric/zoe/src/contractSupport/recorder.js';
+ * @import {VaultManager} from './vaultManager.js';
+ * @import {VaultManagerParamOverrides} from './params.js';
+ * @import {BurnDebt, VaultManagerParamValues} from './types.js';
+ * @import {MintAndTransfer} from './types.js';
+ * @import {VaultFactoryParamPath} from './types.js';
+ * @import {GovernedApis} from '@agoric/governance/src/types.js';
+ * @import {Brand} from '@agoric/ertp';
+ * @import {Amount} from '@agoric/ertp';
+ * @import {Issuer} from '@agoric/ertp';
+ * @import {StorageNode} from '@agoric/internal/src/lib-chainStorage.js';
+ * @import {ERef} from '@agoric/vow';
  */
 
 const trace = makeTracer('VD', true);
@@ -63,13 +77,9 @@ const trace = makeTracer('VD', true);
  *
  * @typedef {{
  *   burnDebt: BurnDebt;
- *   getGovernedParams: (
- *     collateralBrand: Brand,
- *   ) => import('./vaultManager.js').GovernedParamGetters;
+ *   getGovernedParams: (collateralBrand: Brand) => GovernedParamGetters;
  *   mintAndTransfer: MintAndTransfer;
- *   getShortfallReporter: () => Promise<
- *     import('../reserve/assetReserve.js').ShortfallReporter
- *   >;
+ *   getShortfallReporter: () => Promise<ShortfallReporter>;
  * }} FactoryPowersFacet
  *
  *
@@ -77,9 +87,7 @@ const trace = makeTracer('VD', true);
  *   state: State;
  * }>} MethodContext
  *
- * @typedef {import('@agoric/governance/src/contractGovernance/typedParamManager.js').TypedParamManager<
- *     import('./params.js').VaultDirectorParams
- *   >} VaultDirectorParamManager
+ * @typedef {TypedParamManager<VaultDirectorParams>} VaultDirectorParamManager
  */
 
 const shortfallInvitationKey = 'shortfallInvitation';
@@ -100,17 +108,16 @@ export const makeAllManagersDo = (collateralManagers, vaultManagers) => {
 };
 
 /**
- * @param {import('@agoric/swingset-liveslots').Baggage} baggage
- * @param {import('./vaultFactory.js').VaultFactoryZCF} zcf
+ * @param {Baggage} baggage
+ * @param {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 {Record<string, import('./params.js').VaultManagerParamOverrides>} managerParams
+ * @param {ERef<TimerService>} timer
+ * @param {ERemote<StorageNode>} storageNode
+ * @param {ERemote<EMarshaller>} marshaller
+ * @param {MakeRecorderKit} makeRecorderKit
+ * @param {MakeERecorderKit} makeERecorderKit
+ * @param {Record<string, VaultManagerParamOverrides>} managerParams
  */
 const prepareVaultDirector = (
   baggage,
@@ -118,14 +125,13 @@ const prepareVaultDirector = (
   directorParamManager,
   debtMint,
   timer,
-  auctioneer,
   storageNode,
   marshaller,
   makeRecorderKit,
   makeERecorderKit,
   managerParams,
 ) => {
-  /** @type {import('../reserve/assetReserve.js').ShortfallReporter} */
+  /** @type {ShortfallReporter} */
   let shortfallReporter;
 
   /** For holding newly minted tokens until transferred */
@@ -280,14 +286,6 @@ const prepareVaultDirector = (
     metrics: makeRecorderTopic('Vault Factory metrics', metricsKit),
   });
 
-  const allManagersDo = makeAllManagersDo(collateralManagers, vaultManagers);
-
-  const makeWaker = (name, func) => {
-    return Far(name, {
-      wake: timestamp => func(timestamp),
-    });
-  };
-
   /** @returns {State} */
   const initState = () => {
     return {};
@@ -296,7 +294,7 @@ const prepareVaultDirector = (
   /**
    * "Director" of the vault factory, overseeing "vault managers".
    *
-   * @param {import('./vaultFactory.js').VaultFactoryZCF} zcf
+   * @param {VaultFactoryZCF} zcf
    * @param {VaultDirectorParamManager} directorParamManager
    * @param {ZCFMint<'nat'>} debtMint
    */
@@ -313,9 +311,6 @@ const prepareVaultDirector = (
         ),
         makeCollectFeesInvitation: M.call().returns(M.promise()),
         getRewardAllocation: M.call().returns({ Minted: AmountShape }),
-        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', {
@@ -333,7 +328,6 @@ const prepareVaultDirector = (
         getPublicTopics: M.call().returns(TopicsRecordShape),
       }),
       helper: M.interface('helper', {
-        resetWakeupsForNextAuction: M.call().returns(M.promise()),
         start: M.call().returns(M.promise()),
       }),
     },
@@ -401,6 +395,7 @@ const prepareVaultDirector = (
           // zero-based index of the manager being made
           const managerIndex = vaultManagers.length();
           const managerId = `manager${managerIndex}`;
+          /** @type {Remote<StorageNode>} */
           const managerStorageNode =
             await E(managersNode).makeChildNode(managerId);
 
@@ -444,23 +439,6 @@ const prepareVaultDirector = (
           return rewardPoolSeat.getCurrentAllocation();
         },
 
-        makeLiquidationWaker() {
-          return makeWaker('liquidationWaker', _timestamp => {
-            // XXX floating promise
-            allManagersDo(vm => vm.liquidateVaults(auctioneer));
-          });
-        },
-        makeReschedulerWaker() {
-          const { facets } = this;
-          return makeWaker('reschedulerWaker', () => {
-            void facets.helper.resetWakeupsForNextAuction();
-          });
-        },
-        makePriceLockWaker() {
-          return makeWaker('priceLockWaker', () => {
-            allManagersDo(vm => vm.lockOraclePrices());
-          });
-        },
         async setShortfallReporter(newInvitation) {
           const zoe = zcf.getZoeService();
           shortfallReporter = await E(
@@ -513,34 +491,14 @@ const prepareVaultDirector = (
         },
       },
       helper: {
-        resetWakeupsForNextAuction() {
-          const { facets } = this;
-
-          const priceLockWaker = facets.machine.makePriceLockWaker();
-          const liquidationWaker = facets.machine.makeLiquidationWaker();
-          const rescheduleWaker = facets.machine.makeReschedulerWaker();
-          return setWakeupsForNextAuction(
-            auctioneer,
-            timer,
-            priceLockWaker,
-            liquidationWaker,
-            rescheduleWaker,
-          );
-        },
         /** Start non-durable processes (or restart if needed after vat restart) */
         async start() {
-          const { helper, machine } = this.facets;
-
-          await helper.resetWakeupsForNextAuction();
           updateShortfallReporter().catch(err =>
             console.error(
               '🛠️ updateShortfallReporter failed during start(); repair by updating governance',
               err,
             ),
           );
-          // independent of the other one which can be canceled
-          const rescheduleWaker = machine.makeReschedulerWaker();
-          void watchForGovernanceChange(auctioneer, timer, rescheduleWaker);
         },
       },
     },

package/src/vaultFactory/vaultFactory.d.ts

@@ -1,68 +1,26 @@
 /**
  * @typedef {ZCF<
- *   GovernanceTerms<import('./params').VaultDirectorParams> & {
+ *   GovernanceTerms<VaultDirectorParams> & {
  *     priceAuthority: ERef<PriceAuthority>;
  *     reservePublicFacet: AssetReservePublicFacet;
- *     timerService: import('@agoric/time').TimerService;
+ *     timerService: TimerService;
  *   }
  * >} VaultFactoryZCF
  */
-/** @type {ContractMeta} */
-export const meta: ContractMeta;
+/** @type {ContractMeta<typeof start>} */
+export const meta: ContractMeta<typeof start>;
 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>;
+    storageNode: Remote<StorageNode>;
+    marshaller: Remote<Marshaller>;
+    managerParams: Record<string, VaultManagerParamOverrides>;
     directorParamOverrides: [object];
-}, baggage: import("@agoric/swingset-liveslots").Baggage): Promise<{
+}, baggage: Baggage): Promise<{
     creatorFacet: import("@endo/exo").Guarded<{
         getParamMgrRetriever: () => {
-            get: (paramPath?: VaultFactoryParamPath) => import("./vaultDirector.js").VaultDirectorParamManager | import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+            get: (paramPath?: import("./types.js").VaultFactoryParamPath) => import("./vaultDirector.js").VaultDirectorParamManager | import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
                 DebtLimit: "amount";
                 InterestRate: "ratio";
                 LiquidationPadding: "ratio";
@@ -70,8 +28,8 @@ export function start(zcf: VaultFactoryZCF, privateArgs: {
                 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<{
+        } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+            get: (paramPath?: import("./types.js").VaultFactoryParamPath) => import("./vaultDirector.js").VaultDirectorParamManager | import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
                 DebtLimit: "amount";
                 InterestRate: "ratio";
                 LiquidationPadding: "ratio";
@@ -82,13 +40,13 @@ export function start(zcf: VaultFactoryZCF, privateArgs: {
         }>;
         getInvitation(name: string): Promise<Invitation>;
         getLimitedCreatorFacet(): import("@endo/exo").Guarded<{
-            addVaultType(collateralIssuer: Issuer<"nat">, collateralKeyword: Keyword, initialParamValues: VaultManagerParamValues): Promise<import("@endo/exo").Guarded<{
+            addVaultType(collateralIssuer: import("@agoric/ertp").Issuer<"nat">, collateralKeyword: import("@agoric/zoe").Keyword, initialParamValues: import("./types.js").VaultManagerParamValues): Promise<import("@endo/exo").Guarded<{
                 getGovernedParams(): import("./vaultManager.js").GovernedParamGetters;
                 makeVaultKit(seat: ZCFSeat): Promise<{
                     publicSubscribers: {
                         vault: {
                             description: string;
-                            subscriber: globalThis.Subscriber<VaultNotification>;
+                            subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
                             storagePath: Promise<string>;
                         };
                     };
@@ -101,7 +59,7 @@ export function start(zcf: VaultFactoryZCF, privateArgs: {
                         getPublicTopics(): {
                             vault: {
                                 description: string;
-                                subscriber: globalThis.Subscriber<VaultNotification>;
+                                subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
                                 storagePath: Promise<string>;
                             };
                         };
@@ -112,7 +70,7 @@ export function start(zcf: VaultFactoryZCF, privateArgs: {
                         getCurrentDebt(): import("@agoric/ertp").NatAmount;
                         getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
                     }>;
-                    vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+                    vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault.js").VaultNotification>;
                 }>;
                 getCollateralQuote(): PriceQuote;
                 getPublicFacet(): import("@endo/exo").Guarded<{
@@ -120,7 +78,7 @@ export function start(zcf: VaultFactoryZCF, privateArgs: {
                         publicSubscribers: {
                             vault: {
                                 description: string;
-                                subscriber: globalThis.Subscriber<VaultNotification>;
+                                subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
                                 storagePath: Promise<string>;
                             };
                         };
@@ -133,7 +91,7 @@ export function start(zcf: VaultFactoryZCF, privateArgs: {
                             getPublicTopics(): {
                                 vault: {
                                     description: string;
-                                    subscriber: globalThis.Subscriber<VaultNotification>;
+                                    subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
                                     storagePath: Promise<string>;
                                 };
                             };
@@ -144,48 +102,32 @@ export function start(zcf: VaultFactoryZCF, privateArgs: {
                             getCurrentDebt(): import("@agoric/ertp").NatAmount;
                             getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
                         }>;
-                        vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+                        vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault.js").VaultNotification>;
                     }, undefined>>;
                     getQuotes(): import("@agoric/notifier").StoredNotifier<PriceQuote>;
-                    getCompoundedInterest(): Ratio;
+                    getCompoundedInterest(): import("@agoric/ertp").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;
-            }>;
+            getRewardAllocation(): import("@agoric/zoe").Allocation;
             setShortfallReporter(newInvitation: any): Promise<void>;
         }>;
-        getGovernedApis(): ERef<GovernedApis>;
+        getGovernedApis(): ERef<import("@agoric/governance").GovernedApis>;
         getGovernedApiNames(): never[];
         setOfferFilter: (strings: any) => Promise<void>;
     }>;
     publicFacet: import("@endo/exo").Guarded<{
-        getCollateralManager(brandIn: Brand): import("@endo/exo").Guarded<{
+        getCollateralManager(brandIn: import("@agoric/ertp").Brand): import("@endo/exo").Guarded<{
             makeVaultInvitation(): Promise<Invitation<{
                 publicSubscribers: {
                     vault: {
                         description: string;
-                        subscriber: globalThis.Subscriber<VaultNotification>;
+                        subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
                         storagePath: Promise<string>;
                     };
                 };
@@ -198,7 +140,7 @@ export function start(zcf: VaultFactoryZCF, privateArgs: {
                     getPublicTopics(): {
                         vault: {
                             description: string;
-                            subscriber: globalThis.Subscriber<VaultNotification>;
+                            subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
                             storagePath: Promise<string>;
                         };
                     };
@@ -209,42 +151,52 @@ export function start(zcf: VaultFactoryZCF, privateArgs: {
                     getCurrentDebt(): import("@agoric/ertp").NatAmount;
                     getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
                 }>;
-                vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+                vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault.js").VaultNotification>;
             }, undefined>>;
             getQuotes(): import("@agoric/notifier").StoredNotifier<PriceQuote>;
-            getCompoundedInterest(): Ratio;
+            getCompoundedInterest(): import("@agoric/ertp").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>;
+        getDebtIssuer(): import("@agoric/ertp").Issuer<"nat", import("@endo/patterns").Key>;
         getSubscription({ collateralBrand }: {
-            collateralBrand: Brand;
-        }): globalThis.StoredSubscription<globalThis.GovernanceSubscriptionState>;
+            collateralBrand: import("@agoric/ertp").Brand;
+        }): import("@agoric/notifier").StoredSubscription<import("@agoric/governance").GovernanceSubscriptionState>;
         getPublicTopics(): {
             metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./vaultDirector.js").MetricsNotification>;
         };
-        getElectorateSubscription(): globalThis.StoredSubscription<globalThis.GovernanceSubscriptionState>;
+        getElectorateSubscription(): import("@agoric/notifier").StoredSubscription<import("@agoric/governance").GovernanceSubscriptionState>;
         getGovernedParams({ collateralBrand }: {
-            collateralBrand: Brand;
-        }): globalThis.ERef<globalThis.ParamStateRecord>;
-        getDirectorGovernedParams(): globalThis.ERef<globalThis.ParamStateRecord>;
+            collateralBrand: import("@agoric/ertp").Brand;
+        }): ERef<import("@agoric/governance").ParamStateRecord>;
+        getDirectorGovernedParams(): ERef<import("@agoric/governance").ParamStateRecord>;
         getInvitationAmount(name: string): import("@agoric/ertp").SetAmount<import("@agoric/zoe").InvitationDetails>;
     }>;
 }>;
-export type VaultFactoryZCF = ZCF<GovernanceTerms<import("./params").VaultDirectorParams> & {
+export type VaultFactoryZCF = ZCF<GovernanceTerms<VaultDirectorParams> & {
     priceAuthority: ERef<PriceAuthority>;
     reservePublicFacet: AssetReservePublicFacet;
-    timerService: import("@agoric/time").TimerService;
+    timerService: 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 { StorageNode } from '@agoric/internal/src/lib-chainStorage.js';
+import type { Remote } from '@agoric/internal';
+import type { Marshaller } from '@agoric/internal/src/lib-chainStorage.js';
+import type { VaultManagerParamOverrides } from './params.js';
+import type { Baggage } from '@agoric/swingset-liveslots';
 import type { ZCFSeat } from '@agoric/zoe';
 import type { PriceQuote } from '@agoric/zoe/tools/types.js';
+import type { ERef } from '@agoric/vow';
+import type { VaultDirectorParams } from './params.js';
+import type { GovernanceTerms } from '@agoric/governance/src/types.js';
+import type { PriceAuthority } from '@agoric/zoe/tools/types.js';
+import type { AssetReservePublicFacet } from '../reserve/assetReserve.js';
+import type { TimerService } from '@agoric/time';
+import type { ZCF } from '@agoric/zoe';
 import type { ContractOf } from '@agoric/zoe/src/zoeService/utils.js';
 //# sourceMappingURL=vaultFactory.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"vaultFactory.d.ts","sourceRoot":"","sources":["vaultFactory.js"],"names":[],"mappings":"AA6CA;;;;;;;;GAQG;AAEH,yCAAyC;AACzC,mBADW,aAAa,OAAO,KAAK,CAAC,CAgBnC;AAgBK,2BAZI,eAAe,eACf;IACN,aAAa,EAAE,aAAa,CAAC;IAC7B,sBAAsB,EAAE,UAAU,CAAC;IACnC,0BAA0B,EAAE,UAAU,CAAC;IACvC,WAAW,EAAE,OAAO,WAAW,CAAC,CAAC;IACjC,UAAU,EAAE,OAAO,UAAU,CAAC,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;IAC1D,sBAAsB,EAAE,CAAC,MAAM,CAAC,CAAC;CAClC,WACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFjB;8BA1HY,IACZ,gBAAoB,mBAAmB,CAAC,GAAG;IACrC,cAAc,EAAE,KAAK,cAAc,CAAC,CAAC;IACrC,kBAAkB,EAAE,uBAAuB,CAAC;IAC5C,YAAY,EAAE,YAAY,CAAC;CAC5B,CACF;mCAuHU,WAAW,OAAO,KAAK,CAAC;kCA9IoF,aAAa;mCAAb,aAAa;gCAAb,aAAa;iCASzG,0CAA0C;4BAV/C,kBAAkB;gCAWd,0CAA0C;gDAJ1B,aAAa;6BAChC,4BAA4B;6BAPoE,aAAa;gCAE1C,4BAA4B;0BASlG,aAAa;yCARE,aAAa;qCAKjB,iCAAiC;oCAN0B,4BAA4B;6CAG/E,4BAA4B;kCADvC,cAAc;yBAJ6E,aAAa;gCAC1G,qCAAqC"}

package/src/vaultFactory/vaultFactory.js

@@ -1,7 +1,3 @@
-// @jessie-check
-/// <reference types="@agoric/governance/exported" />
-/// <reference types="@agoric/zoe/exported" />
-
 // The vaultFactory owns a number of VaultManagers and a mint for Minted.
 //
 // addVaultType is a closely held method that adds a brand new collateral type.
@@ -19,36 +15,47 @@ import { CONTRACT_ELECTORATE } from '@agoric/governance';
 import { makeParamManagerFromTerms } from '@agoric/governance/src/contractGovernance/typedParamManager.js';
 import { validateElectorate } from '@agoric/governance/src/contractHelper.js';
 import { makeTracer, StorageNodeShape } from '@agoric/internal';
+import { wrapRemoteMarshaller } from '@agoric/internal/src/marshal/wrap-marshaller.js';
 import { makeStoredSubscription, makeSubscriptionKit } from '@agoric/notifier';
 import { M } from '@agoric/store';
 import { provideAll } from '@agoric/zoe/src/contractSupport/durability.js';
 import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport/recorder.js';
 import { E } from '@endo/eventual-send';
 import { FeeMintAccessShape } from '@agoric/zoe/src/typeGuards.js';
-import { InvitationShape } from '../auction/params.js';
 import { SHORTFALL_INVITATION_KEY, vaultDirectorParamTypes } from './params.js';
 import { provideDirector } from './vaultDirector.js';
 
 /**
+ * @import {Remote} from '@agoric/internal';
  * @import {ContractMeta, FeeMintAccess, HandleOffer, Invitation, OfferHandler, TransferPart, ZCF, ZCFMint, ZCFSeat} from '@agoric/zoe';
  * @import {ContractOf} from '@agoric/zoe/src/zoeService/utils.js';
  * @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js';
+ * @import {VaultDirectorParams} from './params.js';
+ * @import {TimerService} from '@agoric/time';
+ * @import {AssetReservePublicFacet} from '../reserve/assetReserve.js';
+ * @import {VaultManagerParamOverrides} from './params.js';
+ * @import {Baggage} from '@agoric/swingset-liveslots';
+ * @import {GovernanceTerms} from '@agoric/governance/src/types.js';
+ * @import {StorageNode} from '@agoric/internal/src/lib-chainStorage.js';
+ * @import {Marshaller} from '@agoric/internal/src/lib-chainStorage.js';
+ * @import {ERef} from '@agoric/vow';
  */
 
 const trace = makeTracer('VF', true);
 
 /**
  * @typedef {ZCF<
- *   GovernanceTerms<import('./params').VaultDirectorParams> & {
+ *   GovernanceTerms<VaultDirectorParams> & {
  *     priceAuthority: ERef<PriceAuthority>;
  *     reservePublicFacet: AssetReservePublicFacet;
- *     timerService: import('@agoric/time').TimerService;
+ *     timerService: TimerService;
  *   }
  * >} VaultFactoryZCF
  */
 
-/** @type {ContractMeta} */
+/** @type {ContractMeta<typeof start>} */
 export const meta = {
+  // @ts-expect-error splitRecord loses the property keys
   privateArgsShape: M.splitRecord(
     {
       marshaller: M.remotable('Marshaller'),
@@ -57,8 +64,8 @@ export const meta = {
     {
       // only necessary on first invocation, not subsequent
       feeMintAccess: FeeMintAccessShape,
-      initialPoserInvitation: InvitationShape,
-      initialShortfallInvitation: InvitationShape,
+      initialPoserInvitation: M.any(),
+      initialShortfallInvitation: M.any(),
     },
   ),
   upgradability: 'canUpgrade',
@@ -71,29 +78,26 @@ harden(meta);
  *   feeMintAccess: FeeMintAccess;
  *   initialPoserInvitation: Invitation;
  *   initialShortfallInvitation: Invitation;
- *   storageNode: ERef<StorageNode>;
- *   marshaller: ERef<Marshaller>;
- *   auctioneerInstance: Instance<import('../auction/auctioneer.js').start>;
- *   managerParams: Record<
- *     string,
- *     import('./params.js').VaultManagerParamOverrides
- *   >;
+ *   storageNode: Remote<StorageNode>;
+ *   marshaller: Remote<Marshaller>;
+ *   managerParams: Record<string, VaultManagerParamOverrides>;
  *   directorParamOverrides: [object];
  * }} privateArgs
- * @param {import('@agoric/swingset-liveslots').Baggage} baggage
+ * @param {Baggage} baggage
  */
 export const start = async (zcf, privateArgs, baggage) => {
   trace('prepare start', privateArgs, [...baggage.keys()]);
   const {
     initialPoserInvitation,
     initialShortfallInvitation,
-    marshaller,
+    marshaller: remoteMarshaller,
     storageNode,
-    auctioneerInstance,
     managerParams,
     directorParamOverrides,
   } = privateArgs;
 
+  const cachingMarshaller = wrapRemoteMarshaller(remoteMarshaller);
+
   trace('awaiting debtMint');
   const { debtMint } = await provideAll(baggage, {
     debtMint: () => zcf.registerFeeMint('Minted', privateArgs.feeMintAccess),
@@ -105,12 +109,9 @@ export const start = async (zcf, privateArgs, baggage) => {
 
   const { timerService } = zcf.getTerms();
 
-  const zoe = zcf.getZoeService();
-  const auctioneerPublicFacet = E(zoe).getPublicFacet(auctioneerInstance);
-
   const { makeRecorderKit, makeERecorderKit } = prepareRecorderKitMakers(
     baggage,
-    marshaller,
+    cachingMarshaller,
   );
 
   trace('making non-durable publishers');
@@ -120,7 +121,7 @@ export const start = async (zcf, privateArgs, baggage) => {
   const governanceSubscriber = makeStoredSubscription(
     governanceSubscriptionKit.subscription,
     governanceNode,
-    marshaller,
+    cachingMarshaller,
   );
   /** a powerful object; can modify the invitation */
   const vaultDirectorParamManager = await makeParamManagerFromTerms(
@@ -143,10 +144,9 @@ export const start = async (zcf, privateArgs, baggage) => {
     vaultDirectorParamManager,
     debtMint,
     timerService,
-    auctioneerPublicFacet,
     storageNode,
     // XXX remove Recorder makers; remove once we excise deprecated kits for governance
-    marshaller,
+    cachingMarshaller,
     makeRecorderKit,
     makeERecorderKit,
     managerParams,