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

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,69 @@ import { InvitationShape } from '../auction/params.js';
 import { SHORTFALL_INVITATION_KEY, vaultDirectorParamTypes } from './params.js';
 import { provideDirector } from './vaultDirector.js';
 
+/**
+ * @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';
+ */
+
 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<import('../auction/auctioneer.js').start>;
+ *   managerParams: Record<
+ *     string,
+ *     import('./params.js').VaultManagerParamOverrides
+ *   >;
+ *   directorParamOverrides: [object];
  * }} 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,
+    directorParamOverrides,
   } = privateArgs;
 
   trace('awaiting debtMint');
@@ -85,7 +103,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,
@@ -102,7 +123,6 @@ export const prepare = async (zcf, privateArgs, baggage) => {
     marshaller,
   );
   /** a powerful object; can modify the invitation */
-  trace('awaiting makeParamManagerFromTerms');
   const vaultDirectorParamManager = await makeParamManagerFromTerms(
     {
       publisher: governanceSubscriptionKit.publication,
@@ -114,6 +134,7 @@ export const prepare = async (zcf, privateArgs, baggage) => {
       [SHORTFALL_INVITATION_KEY]: initialShortfallInvitation,
     },
     vaultDirectorParamTypes,
+    directorParamOverrides,
   );
 
   const director = provideDirector(
@@ -128,6 +149,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 +167,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,170 @@
+export function prepareVaultHolder(baggage: import("@agoric/swingset-liveslots").Baggage, makeRecorderKit: import("@agoric/zoe/src/contractSupport/recorder.js").MakeRecorderKit): (vault: import("@endo/exo").Guarded<{
+    getVaultSeat(): globalThis.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<globalThis.Invitation<string, undefined>>;
+            CloseVault(): Promise<globalThis.Invitation<string, undefined>>;
+            TransferVault(): Promise<globalThis.Invitation</*elided*/ any>>;
+        }>;
+        vault: import("@endo/exo").Guarded<{
+            getPublicTopics(): {
+                vault: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+            makeCloseInvitation(): Promise<globalThis.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<globalThis.Invitation</*elided*/ any>>;
+            getCollateralAmount(): import("@agoric/ertp").NatAmount;
+            getCurrentDebt(): import("@agoric/ertp").NatAmount;
+            getNormalizedDebt(): import("./storeUtils").NormalizedDebt;
+        }>;
+        vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+    }>;
+    liquidating(): void;
+    liquidated(): void;
+    abortLiquidation(): string;
+    makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+    makeCloseInvitation(): Promise<globalThis.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(): globalThis.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<globalThis.Invitation<string, undefined>>;
+                    CloseVault(): Promise<globalThis.Invitation<string, undefined>>;
+                    TransferVault(): Promise<globalThis.Invitation</*elided*/ any>>;
+                }>;
+                vault: import("@endo/exo").Guarded<{
+                    getPublicTopics(): {
+                        vault: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<VaultNotification>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                    makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+                    makeCloseInvitation(): Promise<globalThis.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<globalThis.Invitation</*elided*/ any>>;
+                    getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                    getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                    getNormalizedDebt(): import("./storeUtils").NormalizedDebt;
+                }>;
+                vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+            }>;
+            liquidating(): void;
+            liquidated(): void;
+            abortLiquidation(): string;
+            makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+            makeCloseInvitation(): Promise<globalThis.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<globalThis.Invitation<string, undefined>>;
+        CloseVault(): Promise<globalThis.Invitation<string, undefined>>;
+        TransferVault(): Promise<globalThis.Invitation<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: import("@endo/exo").Guarded</*elided*/ any>;
+            vault: import("@endo/exo").Guarded<{
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+                makeCloseInvitation(): Promise<globalThis.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<globalThis.Invitation</*elided*/ any>>;
+                getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                getNormalizedDebt(): import("./storeUtils").NormalizedDebt;
+            }>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+        }>>;
+    };
+    holder: {
+        getPublicTopics(): {
+            vault: {
+                description: string;
+                subscriber: globalThis.Subscriber<VaultNotification>;
+                storagePath: Promise<string>;
+            };
+        };
+        makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<globalThis.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<globalThis.Invitation<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: import("@endo/exo").Guarded<{
+                AdjustBalances(): Promise<globalThis.Invitation<string, undefined>>;
+                CloseVault(): Promise<globalThis.Invitation<string, undefined>>;
+                TransferVault(): Promise<globalThis.Invitation</*elided*/ any>>;
+            }>;
+            vault: import("@endo/exo").Guarded</*elided*/ any>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+        }>>;
+        getCollateralAmount(): import("@agoric/ertp").NatAmount;
+        getCurrentDebt(): import("@agoric/ertp").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":"AAqCO,4CAHI,OAAO,4BAA4B,EAAE,OAAO,mBAC5C,OAAO,6CAA6C,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;YAqExE;;;eAGG;;;;;;;;;;;;;;;;;;;QA3CH,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;oBAwCtD;;;uBAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAHH;;;mBAGG;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;GAoBV;oBAnHY;IACR,QAAQ,EAAE,OAAO,6CAA6C,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAC;IAC/F,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB"}

package/src/vaultFactory/vaultHolder.js

@@ -1,17 +1,18 @@
-/**
- * @file Use-object for the owner of a vault
- */
+/** @file Use-object for the owner of a vault */
+import { Fail } from '@endo/errors';
 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;
+/**
+ * @import {Key, Pattern} from '@endo/patterns';
+ */
 
 /**
  * @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 +26,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 +49,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 +103,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,33 @@
+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<globalThis.Invitation<string, undefined>>;
+        CloseVault(): Promise<globalThis.Invitation<string, undefined>>;
+        TransferVault(): Promise<globalThis.Invitation</*elided*/ any>>;
+    }>;
+    vault: import("@endo/exo").Guarded<{
+        getPublicTopics(): {
+            vault: {
+                description: string;
+                subscriber: globalThis.Subscriber<VaultNotification>;
+                storagePath: Promise<string>;
+            };
+        };
+        makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+        makeTransferInvitation(): Promise<globalThis.Invitation</*elided*/ any>>;
+        getCollateralAmount(): import("@agoric/ertp").NatAmount;
+        getCurrentDebt(): import("@agoric/ertp").NatAmount;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    }>;
+    vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+};
+export type VaultKit = EReturn<EReturn<typeof prepareVaultKit>>;
+import type { EReturn } from '@endo/far';
+//# 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":"AAoBO,yCAHI,OAAO,4BAA4B,EAAE,OAAO,mBAC5C,OAAO,6CAA6C,EAAE,eAAe,WASnE,KAAK,eACL,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBvB;uBAEa,QAAQ,QAAQ,OAAO,eAAe,CAAC,CAAC;6BAxC5B,WAAW"}

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,14 @@ 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.
+ * @import {EReturn} from '@endo/far';
+ */
+
+/**
+ * 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 +48,4 @@ export const prepareVaultKit = (baggage, makeRecorderKit) => {
   return makeVaultKit;
 };
 
-/** @typedef {(ReturnType<ReturnType<typeof prepareVaultKit>>)} VaultKit */
+/** @typedef {EReturn<EReturn<typeof prepareVaultKit>>} VaultKit */