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

package/src/vaultFactory/vaultFactory.d.ts

@@ -0,0 +1,201 @@
+/**
+ * @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: ERef<AuctioneerPublicFacet>): 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(): 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<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 = ZCF<GovernanceTerms<import("./params").VaultDirectorParams> & {
+    priceAuthority: ERef<PriceAuthority>;
+    reservePublicFacet: AssetReservePublicFacet;
+    timerService: import("@agoric/time").TimerService;
+}>;
+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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqFtD;8BA9HY,GAAG,CACf,eAAmB,CAAC,OAAO,UAAU,EAAE,mBAAmB,CAAC,GAAG;IAC9D,cAAoB,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;IAC3C,kBAAwB,EAAE,uBAAuB,CAAC;IAClD,YAAkB,EAAE,OAAO,cAAc,EAAE,YAAY,CAAC;CACnD,CACF;mCA2HU,UAAU,CAAC,OAAO,KAAK,CAAC;gCAtIwD,4BAA4B;oCAA5B,4BAA4B"}

package/src/vaultFactory/vaultFactory.js

@@ -1,8 +1,6 @@
 // @jessie-check
-
-import '@agoric/governance/exported.js';
-import '@agoric/zoe/exported.js';
-import '@agoric/zoe/src/contracts/exported.js';
+/// <reference types="@agoric/governance/exported" />
+/// <reference types="@agoric/zoe/exported" />
 
 // The vaultFactory owns a number of VaultManagers and a mint for Minted.
 //
@@ -31,49 +29,63 @@ import { InvitationShape } from '../auction/params.js';
 import { SHORTFALL_INVITATION_KEY, vaultDirectorParamTypes } from './params.js';
 import { provideDirector } from './vaultDirector.js';
 
+/** @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js'; */
+
 const trace = makeTracer('VF', true);
 
 /**
- * @typedef {ZCF<GovernanceTerms<import('./params').VaultDirectorParams> & {
- *   auctioneerPublicFacet: import('../auction/auctioneer.js').AuctioneerPublicFacet,
- *   priceAuthority: ERef<PriceAuthority>,
- *   reservePublicFacet: AssetReservePublicFacet,
- *   timerService: import('@agoric/time/src/types').TimerService,
- * }>} VaultFactoryZCF
+ * @typedef {ZCF<
+ *   GovernanceTerms<import('./params').VaultDirectorParams> & {
+ *     priceAuthority: ERef<PriceAuthority>;
+ *     reservePublicFacet: AssetReservePublicFacet;
+ *     timerService: import('@agoric/time').TimerService;
+ *   }
+ * >} VaultFactoryZCF
  */
 
-export const privateArgsShape = M.splitRecord(
-  harden({
-    marshaller: M.remotable('Marshaller'),
-    storageNode: StorageNodeShape,
-  }),
-  harden({
-    // only necessary on first invocation, not subsequent
-    feeMintAccess: FeeMintAccessShape,
-    initialPoserInvitation: InvitationShape,
-    initialShortfallInvitation: InvitationShape,
-  }),
-);
-harden(privateArgsShape);
+/** @type {ContractMeta} */
+export const meta = {
+  privateArgsShape: M.splitRecord(
+    {
+      marshaller: M.remotable('Marshaller'),
+      storageNode: StorageNodeShape,
+    },
+    {
+      // only necessary on first invocation, not subsequent
+      feeMintAccess: FeeMintAccessShape,
+      initialPoserInvitation: InvitationShape,
+      initialShortfallInvitation: InvitationShape,
+    },
+  ),
+  upgradability: 'canUpgrade',
+};
+harden(meta);
 
 /**
  * @param {VaultFactoryZCF} zcf
  * @param {{
- *   feeMintAccess: FeeMintAccess,
- *   initialPoserInvitation: Invitation,
- *   initialShortfallInvitation: Invitation,
- *   storageNode: ERef<StorageNode>,
- *   marshaller: ERef<Marshaller>,
+ *   feeMintAccess: FeeMintAccess;
+ *   initialPoserInvitation: Invitation;
+ *   initialShortfallInvitation: Invitation;
+ *   storageNode: ERef<StorageNode>;
+ *   marshaller: ERef<Marshaller>;
+ *   auctioneerInstance: Instance;
+ *   managerParams: Record<
+ *     string,
+ *     import('./params.js').VaultManagerParamOverrides
+ *   >;
  * }} privateArgs
- * @param {import('@agoric/ertp').Baggage} baggage
+ * @param {import('@agoric/swingset-liveslots').Baggage} baggage
  */
-export const prepare = async (zcf, privateArgs, baggage) => {
+export const start = async (zcf, privateArgs, baggage) => {
   trace('prepare start', privateArgs, [...baggage.keys()]);
   const {
     initialPoserInvitation,
     initialShortfallInvitation,
     marshaller,
     storageNode,
+    auctioneerInstance,
+    managerParams,
   } = privateArgs;
 
   trace('awaiting debtMint');
@@ -85,7 +97,10 @@ export const prepare = async (zcf, privateArgs, baggage) => {
     mintedIssuerRecord: debtMint.getIssuerRecord(),
   }));
 
-  const { timerService, auctioneerPublicFacet } = zcf.getTerms();
+  const { timerService } = zcf.getTerms();
+
+  const zoe = zcf.getZoeService();
+  const auctioneerPublicFacet = E(zoe).getPublicFacet(auctioneerInstance);
 
   const { makeRecorderKit, makeERecorderKit } = prepareRecorderKitMakers(
     baggage,
@@ -128,6 +143,7 @@ export const prepare = async (zcf, privateArgs, baggage) => {
     marshaller,
     makeRecorderKit,
     makeERecorderKit,
+    managerParams,
   );
 
   // cannot await because it would make remote calls during vat restart
@@ -145,5 +161,6 @@ export const prepare = async (zcf, privateArgs, baggage) => {
     publicFacet: director.public,
   });
 };
+harden(start);
 
-/** @typedef {ContractOf<typeof prepare>} VaultFactoryContract */
+/** @typedef {ContractOf<typeof start>} VaultFactoryContract */

package/src/vaultFactory/vaultHolder.d.ts

@@ -0,0 +1,126 @@
+export function prepareVaultHolder(baggage: import("@agoric/swingset-liveslots").Baggage, makeRecorderKit: import("@agoric/zoe/src/contractSupport/recorder.js").MakeRecorderKit): (vault: import("@endo/exo").Guarded<{
+    getVaultSeat(): ZCFSeat;
+    initVaultKit(seat: ZCFSeat, storageNode: StorageNode): 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>>;
+            /**
+             * Starting a transfer revokes the vault holder. The associated updater
+             * will get a special notification that the vault is being transferred.
+             */
+            makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+            getCollateralAmount(): import("@agoric/ertp/src/types").NatAmount;
+            getCurrentDebt(): import("@agoric/ertp/src/types").NatAmount;
+            getNormalizedDebt(): import("./storeUtils").NormalizedDebt;
+        }>;
+        vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+    }>;
+    liquidating(): void;
+    liquidated(): void;
+    abortLiquidation(): string;
+    makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+    makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+    makeTransferInvitation(): Promise<Invitation<VaultKit>>;
+    getCollateralAmount(): Amount<"nat">;
+    getCurrentDebt(): Amount<"nat">;
+    getNormalizedDebt(): import("./storeUtils").NormalizedDebt;
+}>, storageNode: globalThis.StorageNode) => import("@endo/exo").GuardedKit<{
+    helper: {
+        /** @throws if this holder no longer owns the vault */
+        owned(): import("@endo/exo").Guarded<{
+            getVaultSeat(): ZCFSeat;
+            initVaultKit(seat: ZCFSeat, storageNode: StorageNode): 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>>;
+                    /**
+                     * Starting a transfer revokes the vault holder. The associated updater
+                     * will get a special notification that the vault is being transferred.
+                     */
+                    makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+                    getCollateralAmount(): import("@agoric/ertp/src/types").NatAmount;
+                    getCurrentDebt(): import("@agoric/ertp/src/types").NatAmount;
+                    getNormalizedDebt(): import("./storeUtils").NormalizedDebt;
+                }>;
+                vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+            }>;
+            liquidating(): void;
+            liquidated(): void;
+            abortLiquidation(): string;
+            makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+            makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+            makeTransferInvitation(): Promise<Invitation<VaultKit>>;
+            getCollateralAmount(): Amount<"nat">;
+            getCurrentDebt(): Amount<"nat">;
+            getNormalizedDebt(): import("./storeUtils").NormalizedDebt;
+        }>;
+        getUpdater(): import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+    };
+    invitationMakers: {
+        AdjustBalances(): Promise<Invitation<string, undefined>>;
+        CloseVault(): Promise<Invitation<string, undefined>>;
+        TransferVault(): Promise<Invitation<any, undefined>>;
+    };
+    holder: {
+        getPublicTopics(): {
+            vault: {
+                description: string;
+                subscriber: globalThis.Subscriber<VaultNotification>;
+                storagePath: Promise<string>;
+            };
+        };
+        makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+        /**
+         * Starting a transfer revokes the vault holder. The associated updater
+         * will get a special notification that the vault is being transferred.
+         */
+        makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+        getCollateralAmount(): import("@agoric/ertp/src/types").NatAmount;
+        getCurrentDebt(): import("@agoric/ertp/src/types").NatAmount;
+        getNormalizedDebt(): import("./storeUtils").NormalizedDebt;
+    };
+}>;
+export type State = {
+    topicKit: import("@agoric/zoe/src/contractSupport/recorder.js").RecorderKit<VaultNotification>;
+    vault: Vault | null;
+};
+//# sourceMappingURL=vaultHolder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vaultHolder.d.ts","sourceRoot":"","sources":["vaultHolder.js"],"names":[],"mappings":"AAkCO,4CAHI,OAAO,4BAA4B,EAAE,OAAO,mBAC5C,OAAO,6CAA6C,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;YAqExE;;;eAGG;;;;;;;;;;;;;;;;gCAqBu0wB,cAAiB;mDAAzjrB,WAAW;;QAhE7yF,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;oBAwCtD;;;uBAGG;;;;;;;;;;;;;;;;wCAqBu0wB,cAAiB;;;;;;;;;;;;;;;;;;;QAxB31wB;;;WAGG;;;;;;GAoBV;oBAnHY;IACZ,QAAY,EAAE,OAAO,6CAA6C,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAC;IACnG,KAAS,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB"}

package/src/vaultFactory/vaultHolder.js

@@ -1,17 +1,15 @@
-/**
- * @file Use-object for the owner of a vault
- */
+/** @file Use-object for the owner of a vault */
 import { AmountShape } from '@agoric/ertp';
 import { M, prepareExoClassKit } from '@agoric/vat-data';
 import { TopicsRecordShape } from '@agoric/zoe/src/contractSupport/index.js';
-import { UnguardedHelperI } from '../typeGuards.js';
+import { UnguardedHelperI } from '@agoric/internal/src/typeGuards.js';
 
 const { Fail } = assert;
 
 /**
  * @typedef {{
- * topicKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<VaultNotification>,
- * vault: Vault | null,
+ *   topicKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<VaultNotification>;
+ *   vault: Vault | null;
  * }} State
  */
 
@@ -25,13 +23,13 @@ const HolderI = M.interface('holder', {
   makeTransferInvitation: M.call().returns(M.promise()),
 });
 
-/** @type {{ [name: string]: [ description: string, valueShape: Pattern ] }} */
+/** @type {{ [name: string]: [description: string, valueShape: Pattern] }} */
 const PUBLIC_TOPICS = {
   vault: ['Vault holder status', M.any()],
 };
 
 /**
- * @param {import('@agoric/ertp').Baggage} baggage
+ * @param {import('@agoric/swingset-liveslots').Baggage} baggage
  * @param {import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit} makeRecorderKit
  */
 export const prepareVaultHolder = (baggage, makeRecorderKit) => {
@@ -48,22 +46,20 @@ export const prepareVaultHolder = (baggage, makeRecorderKit) => {
       }),
     },
     /**
-     *
      * @param {Vault} vault
      * @param {StorageNode} storageNode
      * @returns {State}
      */
     (vault, storageNode) => {
       // must be the fully synchronous maker because the kit is held in durable state
+      // @ts-expect-error XXX Patterns
       const topicKit = makeRecorderKit(storageNode, PUBLIC_TOPICS.vault[1]);
 
       return { topicKit, vault };
     },
     {
       helper: {
-        /**
-         * @throws if this holder no longer owns the vault
-         */
+        /** @throws if this holder no longer owns the vault */
         owned() {
           const { vault } = this.state;
           if (!vault) {
@@ -104,8 +100,8 @@ export const prepareVaultHolder = (baggage, makeRecorderKit) => {
           return this.facets.helper.owned().makeCloseInvitation();
         },
         /**
-         * Starting a transfer revokes the vault holder. The associated updater will
-         * get a special notification that the vault is being transferred.
+         * Starting a transfer revokes the vault holder. The associated updater
+         * will get a special notification that the vault is being transferred.
          */
         makeTransferInvitation() {
           const vault = this.facets.helper.owned();

package/src/vaultFactory/vaultKit.d.ts

@@ -0,0 +1,32 @@
+export function prepareVaultKit(baggage: import("@agoric/swingset-liveslots").Baggage, makeRecorderKit: import("@agoric/zoe/src/contractSupport/recorder.js").MakeRecorderKit): (vault: Vault, storageNode: StorageNode) => {
+    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>;
+};
+export type VaultKit = ReturnType<ReturnType<typeof prepareVaultKit>>;
+//# sourceMappingURL=vaultKit.d.ts.map

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

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

package/src/vaultFactory/vaultKit.js

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