@agoric/zoe 0.26.3-upgrade-14-dev-0169c7e.0 → 0.26.3-upgrade-16-dev-8879538.0

package/src/zoeService/zoeSeat.js

@@ -1,54 +1,41 @@
-import { prepareDurablePublishKit, SubscriberShape } from '@agoric/notifier';
+/* eslint @typescript-eslint/no-floating-promises: "warn" */
+import { prepareDurablePublishKit } from '@agoric/notifier';
 import { E } from '@endo/eventual-send';
 import { M, prepareExoClassKit } from '@agoric/vat-data';
 import { deeplyFulfilled } from '@endo/marshal';
 import { makePromiseKit } from '@endo/promise-kit';
 
 import { satisfiesWant } from '../contractFacet/offerSafety.js';
-import '../types.js';
+import '../types-ambient.js';
 import '../internal-types.js';
 import {
-  AmountKeywordRecordShape,
-  KeywordShape,
-  ExitObjectShape,
-  PaymentPKeywordRecordShape,
-} from '../typeGuards.js';
+  declareOldZoeSeatAdminKind,
+  OriginalZoeSeatIKit,
+  ZoeUserSeatShape,
+  coreUserSeatMethods,
+} from './originalZoeSeat.js';
 
 const { Fail } = assert;
 
-const ZoeSeatIKit = harden({
-  zoeSeatAdmin: M.interface('ZoeSeatAdmin', {
-    replaceAllocation: M.call(AmountKeywordRecordShape).returns(),
-    exit: M.call(M.any()).returns(),
-    fail: M.call(M.any()).returns(),
-    resolveExitAndResult: M.call({
-      offerResultPromise: M.promise(),
-      exitObj: ExitObjectShape,
-    }).returns(),
-    getExitSubscriber: M.call().returns(SubscriberShape),
-    // The return promise is empty, but doExit relies on settlement as a signal
-    // that the payouts have settled. The exit publisher is notified after that.
-    finalPayouts: M.call(M.eref(PaymentPKeywordRecordShape)).returns(
-      M.promise(),
-    ),
-  }),
-  userSeat: M.interface('UserSeat', {
-    getProposal: M.call().returns(M.promise()),
-    getPayouts: M.call().returns(M.promise()),
-    getPayout: M.call(KeywordShape).returns(M.promise()),
-    getOfferResult: M.call().returns(M.promise()),
-    hasExited: M.call().returns(M.promise()),
-    tryExit: M.call().returns(M.promise()),
-    numWantsSatisfied: M.call().returns(M.promise()),
-    getFinalAllocation: M.call().returns(M.promise()),
-    getExitSubscriber: M.call().returns(M.any()),
+// ZoeSeatAdmin has the implementation of coreUserSeatMethods, but ZoeUserSeat
+// is the facet shared with users. The latter transparently forwards to the
+// former.
+
+const ZoeSeatAdmin = harden({
+  userSeatAccess: M.interface('UserSeatAccess', {
+    ...coreUserSeatMethods,
+    initExitObjectSetter: M.call(M.any()).returns(),
+    assertHasNotExited: M.call(M.string()).returns(),
   }),
+  zoeSeatAdmin: OriginalZoeSeatIKit.zoeSeatAdmin,
 });
 
-const assertHasNotExited = (c, msg) => {
-  !c.state.instanceAdminHelper.hasExited(c.facets.zoeSeatAdmin) ||
-    assert(!c.state.instanceAdminHelper.hasExited(c.facets.zoeSeatAdmin), msg);
-};
+const ZoeUserSeat = harden({
+  userSeat: ZoeUserSeatShape,
+  exitObjSetter: M.interface('exitObjSetter', {
+    setExitObject: M.call(M.or(M.remotable(), M.undefined())).returns(),
+  }),
+});
 
 /**
  * makeZoeSeatAdminFactory returns a maker for an object that manages the state
@@ -69,6 +56,8 @@ export const makeZoeSeatAdminFactory = baggage => {
     'zoe Seat publisher',
   );
 
+  declareOldZoeSeatAdminKind(baggage, makeDurablePublishKit);
+
   const doExit = (
     zoeSeatAdmin,
     currentAllocation,
@@ -96,17 +85,15 @@ export const makeZoeSeatAdminFactory = baggage => {
    */
   const ephemeralOfferResultStore = new WeakMap();
 
-  return prepareExoClassKit(
+  const makeZoeSeatAdmin = prepareExoClassKit(
     baggage,
-    'ZoeSeatKit',
-    ZoeSeatIKit,
+    'ZoeSeatAdmin',
+    ZoeSeatAdmin,
     /**
-     *
      * @param {Allocation} initialAllocation
      * @param {ProposalRecord} proposal
      * @param {InstanceAdminHelper} instanceAdminHelper
      * @param {WithdrawFacet} withdrawFacet
-     * @param {ERef<ExitObj>} [exitObj]
      * @param {boolean} [offerResultIsUndefined]
      */
     (
@@ -114,7 +101,6 @@ export const makeZoeSeatAdminFactory = baggage => {
       proposal,
       instanceAdminHelper,
       withdrawFacet,
-      exitObj = undefined,
       // emptySeatKits start with offerResult validly undefined; others can set
       // it to anything (including undefined) in resolveExitAndResult()
       offerResultIsUndefined = false,
@@ -123,8 +109,7 @@ export const makeZoeSeatAdminFactory = baggage => {
       return {
         currentAllocation: initialAllocation,
         proposal,
-        exitObj,
-        offerResult: undefined,
+        offerResult: /** @type {any} */ (undefined),
         offerResultStored: offerResultIsUndefined,
         instanceAdminHelper,
         withdrawFacet,
@@ -132,14 +117,97 @@ export const makeZoeSeatAdminFactory = baggage => {
         subscriber,
         payouts: harden({}),
         exiting: false,
+        /** @type {{ setExitObject: (exitObj: ExitObj | undefined) => void} | undefined} */
+        exitObjectSetter: undefined,
       };
     },
     {
+      // methods for userSeat to call
+      userSeatAccess: {
+        async getProposal() {
+          const { state } = this;
+          return state.proposal;
+        },
+        async getPayouts() {
+          const { state } = this;
+
+          return E.when(
+            state.subscriber.subscribeAfter(),
+            () => state.payouts,
+            () => state.payouts,
+          );
+        },
+        async getPayout(keyword) {
+          const { state } = this;
+
+          // subscriber.subscribeAfter() only triggers after publisher.finish()
+          // in exit() or publisher.fail() in fail(). Both of those wait for
+          // doExit(), which ensures that finalPayouts() has set state.payouts.
+          return E.when(
+            state.subscriber.subscribeAfter(),
+            () => state.payouts[keyword],
+            () => state.payouts[keyword],
+          );
+        },
+
+        async getOfferResult() {
+          const { state, facets } = this;
+
+          if (state.offerResultStored) {
+            return state.offerResult;
+          }
+
+          if (ephemeralOfferResultStore.has(facets.zoeSeatAdmin)) {
+            return ephemeralOfferResultStore.get(facets.zoeSeatAdmin).promise;
+          }
+
+          const kit = makePromiseKit();
+          ephemeralOfferResultStore.set(facets.zoeSeatAdmin, kit);
+          return kit.promise;
+        },
+        async hasExited() {
+          const { state, facets } = this;
+
+          return (
+            state.exiting ||
+            state.instanceAdminHelper.hasExited(facets.zoeSeatAdmin)
+          );
+        },
+        async numWantsSatisfied() {
+          const { state } = this;
+          return E.when(
+            state.subscriber.subscribeAfter(),
+            () => satisfiesWant(state.proposal, state.currentAllocation),
+            () => satisfiesWant(state.proposal, state.currentAllocation),
+          );
+        },
+        getExitSubscriber() {
+          const { state } = this;
+          return state.subscriber;
+        },
+        getFinalAllocation() {
+          const { state } = this;
+          return E.when(
+            state.subscriber.subscribeAfter(),
+            () => state.currentAllocation,
+            () => state.currentAllocation,
+          );
+        },
+        initExitObjectSetter(setter) {
+          this.state.exitObjectSetter = setter;
+        },
+        assertHasNotExited(msg) {
+          const { state, facets } = this;
+          const { instanceAdminHelper } = state;
+          const hasExited1 = instanceAdminHelper.hasExited(facets.zoeSeatAdmin);
+
+          !hasExited1 || assert(!hasExited1, msg);
+        },
+      },
       zoeSeatAdmin: {
         replaceAllocation(replacementAllocation) {
-          const { state } = this;
-          assertHasNotExited(
-            this,
+          const { state, facets } = this;
+          facets.userSeatAccess.assertHasNotExited(
             'Cannot replace allocation. Seat has already exited',
           );
           harden(replacementAllocation);
@@ -155,7 +223,9 @@ export const makeZoeSeatAdminFactory = baggage => {
           if (state.exiting) {
             return;
           }
-          assertHasNotExited(this, 'Cannot exit seat. Seat has already exited');
+          facets.userSeatAccess.assertHasNotExited(
+            'Cannot exit seat. Seat has already exited',
+          );
 
           state.exiting = true;
           E.when(
@@ -165,7 +235,13 @@ export const makeZoeSeatAdminFactory = baggage => {
               state.withdrawFacet,
               state.instanceAdminHelper,
             ),
-            () => state.publisher.finish(completion),
+            () => {
+              if (state.exitObjectSetter) {
+                state.exitObjectSetter.setExitObject(undefined);
+                state.exitObjectSetter = undefined;
+              }
+              return state.publisher.finish(completion);
+            },
           );
         },
         fail(reason) {
@@ -176,10 +252,12 @@ export const makeZoeSeatAdminFactory = baggage => {
             return;
           }
 
-          assertHasNotExited(this, 'Cannot fail seat. Seat has already exited');
+          facets.userSeatAccess.assertHasNotExited(
+            'Cannot fail seat. Seat has already exited',
+          );
 
           state.exiting = true;
-          E.when(
+          void E.when(
             doExit(
               facets.zoeSeatAdmin,
               state.currentAllocation,
@@ -189,6 +267,11 @@ export const makeZoeSeatAdminFactory = baggage => {
             () => state.publisher.fail(reason),
             () => state.publisher.fail(reason),
           );
+
+          if (state.exitObjectSetter) {
+            state.exitObjectSetter.setExitObject(undefined);
+            state.exitObjectSetter = undefined;
+          }
         },
         // called only for seats resulting from offers.
         /** @param {HandleOfferResult} result */
@@ -198,15 +281,15 @@ export const makeZoeSeatAdminFactory = baggage => {
           !state.offerResultStored ||
             Fail`offerResultStored before offerResultPromise`;
 
-          if (!ephemeralOfferResultStore.has(facets.userSeat)) {
+          if (!ephemeralOfferResultStore.has(facets.zoeSeatAdmin)) {
             // this was called before getOfferResult
             const kit = makePromiseKit();
             kit.resolve(offerResultPromise);
-            ephemeralOfferResultStore.set(facets.userSeat, kit);
+            ephemeralOfferResultStore.set(facets.zoeSeatAdmin, kit);
           }
 
-          const pKit = ephemeralOfferResultStore.get(facets.userSeat);
-          E.when(
+          const pKit = ephemeralOfferResultStore.get(facets.zoeSeatAdmin);
+          void E.when(
             offerResultPromise,
             offerResult => {
               // Resolve the ephemeral promise for offerResult
@@ -226,10 +309,11 @@ export const makeZoeSeatAdminFactory = baggage => {
                     // If it doesn't, then these lines won't be reached so the
                     // flag will stay false and the promise will stay in the heap
                     state.offerResultStored = true;
-                    ephemeralOfferResultStore.delete(facets.userSeat);
+                    ephemeralOfferResultStore.delete(facets.zoeSeatAdmin);
                   } catch (err) {
                     console.warn(
-                      `non-durable offer result will be lost upon zoe vat termination: ${offerResult}`,
+                      'non-durable offer result will be lost upon zoe vat termination:',
+                      offerResult,
                     );
                   }
                 },
@@ -244,7 +328,8 @@ export const makeZoeSeatAdminFactory = baggage => {
             },
           );
 
-          state.exitObj = exitObj;
+          // @ts-expect-error exitObjectSetter is set at birth.
+          state.exitObjectSetter.setExitObject(exitObj);
         },
         getExitSubscriber() {
           const { state } = this;
@@ -257,85 +342,100 @@ export const makeZoeSeatAdminFactory = baggage => {
           state.payouts = settledPayouts;
         },
       },
+    },
+  );
+
+  const makeUserSeat = prepareExoClassKit(
+    baggage,
+    'ZoeUserSeat',
+    ZoeUserSeat,
+    (userSeatAccess, exitObj) => {
+      return {
+        userSeatAccess,
+        exitObj,
+      };
+    },
+    {
       userSeat: {
         async getProposal() {
-          const { state } = this;
-          return state.proposal;
+          return this.state.userSeatAccess.getProposal();
         },
         async getPayouts() {
-          const { state } = this;
-
-          return E.when(
-            state.subscriber.subscribeAfter(),
-            () => state.payouts,
-            () => state.payouts,
-          );
+          return this.state.userSeatAccess.getPayouts();
         },
         async getPayout(keyword) {
-          const { state } = this;
-
-          // subscriber.subscribeAfter() only triggers after publisher.finish()
-          // in exit() or publisher.fail() in fail(). Both of those wait for
-          // doExit(), which ensures that finalPayouts() has set state.payouts.
-          return E.when(
-            state.subscriber.subscribeAfter(),
-            () => state.payouts[keyword],
-            () => state.payouts[keyword],
-          );
+          return this.state.userSeatAccess.getPayout(keyword);
         },
 
         async getOfferResult() {
-          const { state, facets } = this;
-
-          if (state.offerResultStored) {
-            return state.offerResult;
-          }
-
-          if (ephemeralOfferResultStore.has(facets.userSeat)) {
-            return ephemeralOfferResultStore.get(facets.userSeat).promise;
-          }
-
-          const kit = makePromiseKit();
-          ephemeralOfferResultStore.set(facets.userSeat, kit);
-          return kit.promise;
+          return this.state.userSeatAccess.getOfferResult();
         },
         async hasExited() {
-          const { state, facets } = this;
-
-          return (
-            state.exiting ||
-            state.instanceAdminHelper.hasExited(facets.zoeSeatAdmin)
-          );
+          return this.state.userSeatAccess.hasExited();
         },
         async tryExit() {
           const { state } = this;
+
+          state.userSeatAccess.assertHasNotExited(
+            'Cannot exit; seat has already exited',
+          );
           if (!state.exitObj)
-            throw Fail`exitObj must be initialized before use`;
-          assertHasNotExited(this, 'Cannot exit; seat has already exited');
+            throw Fail`exitObj not initialized or already nullified`;
+
+          const exitResult = E(state.exitObj).exit();
 
-          return E(state.exitObj).exit();
+          // unlink an un-collectible cycle.
+          state.exitObj = undefined;
+
+          return exitResult;
         },
         async numWantsSatisfied() {
-          const { state } = this;
-          return E.when(
-            state.subscriber.subscribeAfter(),
-            () => satisfiesWant(state.proposal, state.currentAllocation),
-            () => satisfiesWant(state.proposal, state.currentAllocation),
-          );
+          return this.state.userSeatAccess.numWantsSatisfied();
         },
         getExitSubscriber() {
-          const { state } = this;
-          return state.subscriber;
+          return this.state.userSeatAccess.getExitSubscriber();
         },
         getFinalAllocation() {
-          const { state } = this;
-          return E.when(
-            state.subscriber.subscribeAfter(),
-            () => state.currentAllocation,
-            () => state.currentAllocation,
-          );
+          return this.state.userSeatAccess.getFinalAllocation();
+        },
+      },
+      exitObjSetter: {
+        setExitObject(exitObject) {
+          this.state.exitObj = exitObject;
         },
       },
     },
   );
+
+  /**
+   * @param {Allocation} initialAllocation
+   * @param {ProposalRecord} proposal
+   * @param {InstanceAdminHelper} instanceAdminHelper
+   * @param {WithdrawFacet} withdrawFacet
+   * @param {ERef<ExitObj>} [exitObj]
+   * @param {boolean} [offerResultIsUndefined]
+   */
+  const makeZoeSeatAdminKit = (
+    initialAllocation,
+    proposal,
+    instanceAdminHelper,
+    withdrawFacet,
+    exitObj = undefined,
+    offerResultIsUndefined = false,
+  ) => {
+    const { zoeSeatAdmin, userSeatAccess } = makeZoeSeatAdmin(
+      initialAllocation,
+      proposal,
+      instanceAdminHelper,
+      withdrawFacet,
+      offerResultIsUndefined,
+    );
+    const { userSeat, exitObjSetter } = makeUserSeat(userSeatAccess, exitObj);
+    userSeatAccess.initExitObjectSetter(exitObjSetter);
+
+    // The original makeZoeSeatAdminKit returned two facets of the same kind.
+    // This is returning two independent facets.
+    return { userSeat, zoeSeatAdmin };
+  };
+  return makeZoeSeatAdminKit;
 };

package/src/zoeService/zoeStorageManager.d.ts

@@ -1,10 +1,10 @@
-export function makeZoeStorageManager(createZCFVat: CreateZCFVat, getBundleCapForID: GetBundleCapForID, shutdownZoeVat: ShutdownWithFailure, feeMint: {
+export function makeZoeStorageManager(createZCFVat: CreateZCFVat, getBundleCapForID: GetBundleCapForID, shutdownZoeVat: import("@agoric/swingset-vat").ShutdownWithFailure, feeMint: {
     getFeeIssuerKit: GetFeeIssuerKit;
     getFeeIssuer: () => Issuer;
     getFeeBrand: () => Brand;
-}, zoeBaggage: MapStore<string, unknown>): {
+}, zoeBaggage: Baggage): import("@endo/exo").GuardedKit<{
     zoeServiceDataAccess: {
-        getInvitationIssuer: () => Issuer<"set">;
+        getInvitationIssuer: () => globalThis.Issuer<"set", InvitationDetails>;
         getBundleIDFromInstallation(allegedInstallation: any): any;
         getPublicFacet(instance: any): any;
         getBrands(instance: any): any;
@@ -14,19 +14,19 @@ export function makeZoeStorageManager(createZCFVat: CreateZCFVat, getBundleCapFo
         getInstallation(instance: any): any;
         getProposalShapeForInvitation: (invitationHandle: any) => any;
         installBundle: (allegedBundle: any, bundleLabel: any) => any;
-        installBundleID(bundleID: any, bundleLabel: any): Promise<Installation<any>>;
+        installBundleID(bundleID: any, bundleLabel: any): Promise<Installation<unknown>>;
     };
     makeOfferAccess: {
         getAssetKindByBrand: GetAssetKindByBrand;
         getInstanceAdmin(instance: any): any;
         getProposalShapeForInvitation: (invitationHandle: any) => any;
-        getInvitationIssuer: () => Issuer<"set">;
-        depositPayments(proposal: any, payments: any): Promise<AmountKeywordRecord>;
+        getInvitationIssuer: () => globalThis.Issuer<"set", InvitationDetails>;
+        depositPayments(proposal: any, payments: any): Promise<Allocation>;
     };
     startInstanceAccess: {
         makeZoeInstanceStorageManager: MakeZoeInstanceStorageManager;
         /** @type {UnwrapInstallation} */
-        unwrapInstallation(installationP: ERef<Installation<any>>): ERef<{
+        unwrapInstallation(installationP: ERef<Installation>): globalThis.ERef<{
             bundle?: SourceBundle | undefined;
             bundleCap?: any;
             bundleID?: string | undefined;
@@ -34,42 +34,8 @@ export function makeZoeStorageManager(createZCFVat: CreateZCFVat, getBundleCapFo
         }>;
     };
     invitationIssuerAccess: {
-        getInvitationIssuer: () => Issuer<"set">;
-    };
-} & import("@endo/eventual-send").RemotableBrand<{}, {
-    zoeServiceDataAccess: {
-        getInvitationIssuer: () => Issuer<"set">;
-        getBundleIDFromInstallation(allegedInstallation: any): any;
-        getPublicFacet(instance: any): any;
-        getBrands(instance: any): any;
-        getIssuers(instance: any): any;
-        getOfferFilter(instance: any): any;
-        getTerms(instance: any): any;
-        getInstallation(instance: any): any;
-        getProposalShapeForInvitation: (invitationHandle: any) => any;
-        installBundle: (allegedBundle: any, bundleLabel: any) => any;
-        installBundleID(bundleID: any, bundleLabel: any): Promise<Installation<any>>;
-    };
-    makeOfferAccess: {
-        getAssetKindByBrand: GetAssetKindByBrand;
-        getInstanceAdmin(instance: any): any;
-        getProposalShapeForInvitation: (invitationHandle: any) => any;
-        getInvitationIssuer: () => Issuer<"set">;
-        depositPayments(proposal: any, payments: any): Promise<AmountKeywordRecord>;
-    };
-    startInstanceAccess: {
-        makeZoeInstanceStorageManager: MakeZoeInstanceStorageManager;
-        /** @type {UnwrapInstallation} */
-        unwrapInstallation(installationP: ERef<Installation<any>>): ERef<{
-            bundle?: SourceBundle | undefined;
-            bundleCap?: any;
-            bundleID?: string | undefined;
-            installation: Installation<any>;
-        }>;
-    };
-    invitationIssuerAccess: {
-        getInvitationIssuer: () => Issuer<"set">;
+        getInvitationIssuer: () => globalThis.Issuer<"set", InvitationDetails>;
     };
 }>;
-export type Baggage = import('@agoric/vat-data').Baggage;
+import type { Baggage } from '@agoric/vat-data';
 //# sourceMappingURL=zoeStorageManager.d.ts.map

package/src/zoeService/zoeStorageManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zoeStorageManager.d.ts","sourceRoot":"","sources":["zoeStorageManager.js"],"names":[],"mappings":"AAwDO,oDAXI,YAAY,qBAEZ,iBAAiB,kBACjB,mBAAmB,WACnB;IACV,eAAoB,EAAE,eAAe,CAAC;IACtC,YAAiB,EAAE,MAAM,MAAM,CAAC;IAChC,WAAgB,EAAE,MAAM,KAAK,CAAC;CAC3B;;;;;;;;;;;;;;;;;;;;;;;QA+ZI,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAAjC,iCAAiC;;;;;;;;;;;GAYxC;sBAjca,OAAO,kBAAkB,EAAE,OAAO"}
+{"version":3,"file":"zoeStorageManager.d.ts","sourceRoot":"","sources":["zoeStorageManager.js"],"names":[],"mappings":"AAwDO,oDAXI,YAAY,qBAEZ,iBAAiB,kBACjB,OAAO,sBAAsB,EAAE,mBAAmB,WAClD;IACV,eAAoB,EAAE,eAAe,CAAC;IACtC,YAAiB,EAAE,MAAM,MAAM,CAAC;IAChC,WAAgB,EAAE,MAAM,KAAK,CAAC;CAC3B;;;;;;;;;;;;;;;;;;;;;;;QAiaI,iCAAiC;0CA7agB,KAAM,YAC3D,CAAC;;;;;;;;;;GAwbJ;6BAnc0B,kBAAkB"}

package/src/zoeService/zoeStorageManager.js

@@ -3,7 +3,7 @@ import {
   AssetKind,
   makeDurableIssuerKit,
   AmountMath,
-  prepareIssuerKit,
+  upgradeIssuerKit,
 } from '@agoric/ertp';
 import {
   makeScalarBigMapStore,
@@ -21,7 +21,7 @@ import { prepareInvitationKit } from './makeInvitation.js';
 import { makeInstanceAdminStorage } from './instanceAdminStorage.js';
 import { makeInstallationStorage } from './installationStorage.js';
 
-import './types.js';
+/// <reference path="./types.js" />
 import './internal-types.js';
 import {
   InstanceStorageManagerIKit,
@@ -29,7 +29,7 @@ import {
   ZoeStorageManagerIKit,
 } from '../typeGuards.js';
 
-/** @typedef {import('@agoric/vat-data').Baggage} Baggage */
+/** @import {Baggage} from '@agoric/vat-data' */
 
 const { ownKeys } = Reflect;
 
@@ -46,7 +46,7 @@ const { ownKeys } = Reflect;
  * @param {CreateZCFVat} createZCFVat - the ability to create a new
  * ZCF Vat
  * @param {GetBundleCapForID} getBundleCapForID
- * @param {ShutdownWithFailure} shutdownZoeVat
+ * @param {import('@agoric/swingset-vat').ShutdownWithFailure} shutdownZoeVat
  * @param {{
  *    getFeeIssuerKit: GetFeeIssuerKit,
  *    getFeeIssuer: () => Issuer,
@@ -122,7 +122,7 @@ export const makeZoeStorageManager = (
     'zoeMintBaggageSet',
   );
   for (const issuerBaggage of zoeMintBaggageSet.values()) {
-    prepareIssuerKit(issuerBaggage);
+    upgradeIssuerKit(issuerBaggage);
   }
 
   const makeZoeMint = prepareExoClass(
@@ -275,8 +275,9 @@ export const makeZoeStorageManager = (
             ownKeys(customDetails).length >= 1
               ? harden({ customDetails })
               : harden({});
+          /** @type {InvitationAmount} */
           const invitationAmount = AmountMath.make(
-            invitationKit.brand,
+            /** @type {Brand<'set'>} */ (invitationKit.brand),
             harden([
               {
                 ...extraProperties,
@@ -401,6 +402,7 @@ export const makeZoeStorageManager = (
       contractBundleCap,
       contractLabel,
     );
+    // @ts-expect-error checked cast
     return makeInstanceStorageManager(instanceRecord, adminNode, root)
       .instanceStorageManager;
   };

package/tools/fakePriceAuthority.d.ts

@@ -4,8 +4,8 @@
  * @property {Brand<'nat'>} actualBrandOut
  * @property {Array<number>} [priceList]
  * @property {Array<[number, number]>} [tradeList]
- * @property {ERef<import('@agoric/time/src/types').TimerService>} timer
- * @property {import('@agoric/time/src/types').RelativeTime} [quoteInterval]
+ * @property {import('@agoric/time').TimerService} timer
+ * @property {import('@agoric/time').RelativeTime} [quoteInterval]
  * @property {ERef<Mint<'set'>>} [quoteMint]
  * @property {Amount<'nat'>} [unitAmountIn]
  */
@@ -18,13 +18,14 @@
  */
 export function makeFakePriceAuthority(options: FakePriceAuthorityOptions): Promise<PriceAuthority>;
 export type FakePriceAuthorityOptions = {
-    actualBrandIn: Brand<'nat'>;
-    actualBrandOut: Brand<'nat'>;
+    actualBrandIn: Brand<"nat">;
+    actualBrandOut: Brand<"nat">;
     priceList?: number[] | undefined;
     tradeList?: [number, number][] | undefined;
-    timer: ERef<import('@agoric/time/src/types').TimerService>;
-    quoteInterval?: import("@agoric/time/src/types").RelativeTime | undefined;
-    quoteMint?: ERef<Mint<"set">> | undefined;
-    unitAmountIn?: Amount<"nat"> | undefined;
+    timer: import("@agoric/time").TimerService;
+    quoteInterval?: import("@agoric/time").RelativeTime | undefined;
+    quoteMint?: globalThis.ERef<globalThis.Mint<"set">> | undefined;
+    unitAmountIn?: import("@agoric/ertp/src/types.js").NatAmount | undefined;
 };
+import type { PriceAuthority } from '@agoric/zoe/tools/types.js';
 //# sourceMappingURL=fakePriceAuthority.d.ts.map

package/tools/fakePriceAuthority.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fakePriceAuthority.d.ts","sourceRoot":"","sources":["fakePriceAuthority.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;GAUG;AAEH;;;;;;GAMG;AACH,gDAHW,yBAAyB,GACvB,QAAQ,cAAc,CAAC,CAsSnC;;mBArTa,MAAM,KAAK,CAAC;oBACZ,MAAM,KAAK,CAAC;;;WAGZ,KAAK,OAAO,wBAAwB,EAAE,YAAY,CAAC"}
+{"version":3,"file":"fakePriceAuthority.d.ts","sourceRoot":"","sources":["fakePriceAuthority.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;GAUG;AAEH;;;;;;GAMG;AACH,gDAHW,yBAAyB,2BAySnC;;mBAvTa,KAAK,CAAC,KAAK,CAAC;oBACZ,KAAK,CAAC,KAAK,CAAC;;;WAGZ,OAAO,cAAc,EAAE,YAAY;;;;;oCAjB4C,4BAA4B"}