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

package/src/zoeService/feeMint.js

@@ -1,9 +1,9 @@
 import {
-  makeDurableIssuerKit,
   AssetKind,
-  prepareIssuerKit,
   IssuerShape,
   BrandShape,
+  prepareIssuerKit,
+  hasIssuer,
 } from '@agoric/ertp';
 import { initEmpty, M } from '@agoric/store';
 import {
@@ -13,8 +13,9 @@ import {
 } from '@agoric/vat-data';
 import { FeeMintAccessShape } from '../typeGuards.js';
 
-const { Fail } = assert;
+const { Fail, quote: q } = assert;
 
+/** @deprecated Redundant. Just omit it. */
 const FEE_MINT_KIT = 'FeeMintKit';
 
 export const defaultFeeIssuerConfig = harden(
@@ -28,23 +29,28 @@ export const defaultFeeIssuerConfig = harden(
 /**
  * @param {import('@agoric/vat-data').Baggage} zoeBaggage
  * @param {FeeIssuerConfig} feeIssuerConfig
- * @param {ShutdownWithFailure} shutdownZoeVat
+ * @param {import('@agoric/swingset-vat').ShutdownWithFailure} shutdownZoeVat
  */
 const prepareFeeMint = (zoeBaggage, feeIssuerConfig, shutdownZoeVat) => {
   const mintBaggage = provideDurableMapStore(zoeBaggage, 'mintBaggage');
-  if (!mintBaggage.has(FEE_MINT_KIT)) {
-    /** @type {IssuerKit} */
-    const feeIssuerKit = makeDurableIssuerKit(
+  if (mintBaggage.has(FEE_MINT_KIT)) {
+    hasIssuer(mintBaggage) ||
+      Fail`Legacy ${q(
+        FEE_MINT_KIT,
+      )} must be redundant with normal storing of issuerKit in issuerBaggage`;
+    // Upgrade this legacy state by simply deleting it.
+    mintBaggage.delete(FEE_MINT_KIT);
+  }
+
+  const feeIssuerKit = /** @type {IssuerKit<'nat'>} */ (
+    prepareIssuerKit(
       mintBaggage,
       feeIssuerConfig.name,
       feeIssuerConfig.assetKind,
       feeIssuerConfig.displayInfo,
       shutdownZoeVat,
-    );
-    mintBaggage.init(FEE_MINT_KIT, feeIssuerKit);
-  } else {
-    prepareIssuerKit(mintBaggage, shutdownZoeVat);
-  }
+    )
+  );
 
   const FeeMintIKit = harden({
     feeMint: M.interface('FeeMint', {
@@ -66,13 +72,13 @@ const prepareFeeMint = (zoeBaggage, feeIssuerConfig, shutdownZoeVat) => {
           const { facets } = this;
           facets.feeMintAccess === allegedFeeMintAccess ||
             Fail`The object representing access to the fee brand mint was not provided`;
-          return mintBaggage.get(FEE_MINT_KIT);
+          return feeIssuerKit;
         },
         getFeeIssuer() {
-          return mintBaggage.get(FEE_MINT_KIT).issuer;
+          return feeIssuerKit.issuer;
         },
         getFeeBrand() {
-          return mintBaggage.get(FEE_MINT_KIT).brand;
+          return feeIssuerKit.brand;
         },
       },
       // feeMintAccess is an opaque durable object representing the right to get

package/src/zoeService/installationStorage.d.ts

@@ -1,21 +1,6 @@
-export function makeInstallationStorage(getBundleCapForID: GetBundleCapForID, zoeBaggage: MapStore<string, unknown>): {
+export function makeInstallationStorage(getBundleCapForID: GetBundleCapForID, zoeBaggage: Baggage): import("@endo/exo").Guarded<{
     installBundle(allegedBundle: any, bundleLabel: any): any;
-    installBundleID(bundleID: any, bundleLabel?: any): Promise<Installation<any>>;
-    unwrapInstallation(installation: any): {
-        bundleCap: any;
-        bundleID: string;
-        installation: any;
-        bundle?: undefined;
-    } | {
-        bundle: SourceBundle;
-        installation: any;
-        bundleCap?: undefined;
-        bundleID?: undefined;
-    };
-    getBundleIDFromInstallation(allegedInstallation: any): any;
-} & import("@endo/eventual-send").RemotableBrand<{}, {
-    installBundle(allegedBundle: any, bundleLabel: any): any;
-    installBundleID(bundleID: any, bundleLabel?: any): Promise<Installation<any>>;
+    installBundleID(bundleID: any, bundleLabel?: any): Promise<Installation<unknown>>;
     unwrapInstallation(installation: any): {
         bundleCap: any;
         bundleID: string;
@@ -29,7 +14,7 @@ export function makeInstallationStorage(getBundleCapForID: GetBundleCapForID, zo
     };
     getBundleIDFromInstallation(allegedInstallation: any): any;
 }>;
-export type BundleCap = import('@agoric/swingset-vat').BundleCap;
-export type BundleID = import('@agoric/swingset-vat').BundleID;
-export type Baggage = import('@agoric/vat-data').Baggage;
+export type BundleCap = import("@agoric/swingset-vat").BundleCap;
+export type BundleID = import("@agoric/swingset-vat").BundleID;
+import type { Baggage } from '@agoric/vat-data';
 //# sourceMappingURL=installationStorage.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"installationStorage.d.ts","sourceRoot":"","sources":["installationStorage.js"],"names":[],"mappings":"AAuBO,2DAHI,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4I3B;wBAjJc,OAAO,sBAAsB,EAAE,SAAS;uBACxC,OAAO,sBAAsB,EAAE,QAAQ;sBACxC,OAAO,kBAAkB,EAAE,OAAO"}
+{"version":3,"file":"installationStorage.d.ts","sourceRoot":"","sources":["installationStorage.js"],"names":[],"mappings":"AAuBO,2DAHI,iBAAiB;;;;;;;;;;;;;;;GAgJ3B;wBArJc,OAAO,sBAAsB,EAAE,SAAS;uBACxC,OAAO,sBAAsB,EAAE,QAAQ;6BAC3B,kBAAkB"}

package/src/zoeService/installationStorage.js

@@ -15,7 +15,7 @@ const { Fail, quote: q } = assert;
 
 /** @typedef { import('@agoric/swingset-vat').BundleCap} BundleCap */
 /** @typedef { import('@agoric/swingset-vat').BundleID} BundleID */
-/** @typedef {import('@agoric/vat-data').Baggage} Baggage */
+/** @import {Baggage} from '@agoric/vat-data' */
 
 /**
  * @param {GetBundleCapForID} getBundleCapForID
@@ -33,20 +33,24 @@ export const makeInstallationStorage = (getBundleCapForID, zoeBaggage) => {
     'installationsBundle',
   );
 
+  /** @type {(bundleLabel: string) => Installation<unknown>} */
   const makeBundleIDInstallation = prepareKind(
     zoeBaggage,
     'BundleIDInstallation',
     bundleLabel => ({ bundleLabel }),
+    // @ts-expect-error cast without StartFunction property
     {
       getBundle: _context => Fail`bundleID-based Installation`,
       getBundleLabel: ({ state: { bundleLabel } }) => bundleLabel,
     },
   );
 
+  /** @type {(bundle: SourceBundle, bundleLabel?: string) => Installation<unknown>} */
   const makeBundleInstallation = prepareKind(
     zoeBaggage,
     'BundleInstallation',
     (bundle, bundleLabel) => ({ bundle, bundleLabel }),
+    // @ts-expect-error cast without StartFunction property
     {
       getBundle: ({ state: { bundle } }) => bundle,
       getBundleLabel: ({ state: { bundleLabel } }) => bundleLabel,
@@ -68,8 +72,6 @@ export const makeInstallationStorage = (getBundleCapForID, zoeBaggage) => {
     typeof bundle === 'object' || Fail`a bundle must be provided`;
     /** @type {Installation} */
     bundle || Fail`a bundle must be provided`;
-    /** @type {Installation} */
-    // @ts-expect-error cast
     const installation = makeBundleInstallation(bundle, bundleLabel);
     installationsBundle.init(installation, bundle);
     return installation;
@@ -81,8 +83,12 @@ export const makeInstallationStorage = (getBundleCapForID, zoeBaggage) => {
         InstanceHandleShape,
         M.recordOf(M.string(), M.string({ stringLengthLimit: Infinity })),
       ),
-    ).returns(M.promise()),
-    installBundleID: M.call(M.string()).returns(M.promise()),
+    )
+      .optional(M.string())
+      .returns(M.promise()),
+    installBundleID: M.call(M.string())
+      .optional(M.string())
+      .returns(M.promise()),
     unwrapInstallation: M.callWhen(M.await(InstallationShape)).returns(
       UnwrappedInstallationShape,
     ),
@@ -125,8 +131,6 @@ export const makeInstallationStorage = (getBundleCapForID, zoeBaggage) => {
         const bundleCap = await getBundleCapForID(bundleID);
         // AWAIT
 
-        /** @type {Installation} */
-        // @ts-expect-error cast
         const installation = makeBundleIDInstallation(bundleLabel);
         installationsBundleCap.init(
           installation,

package/src/zoeService/instanceAdminStorage.d.ts

@@ -1,4 +1,4 @@
-export function makeInstanceAdminStorage(baggage: MapStore<string, unknown>): {
+export function makeInstanceAdminStorage(baggage: import("@agoric/vat-data").Baggage): import("@endo/exo").GuardedKit<{
     accessor: {
         getPublicFacet(instance: any): any;
         getBrands(instance: any): any;
@@ -9,25 +9,11 @@ export function makeInstanceAdminStorage(baggage: MapStore<string, unknown>): {
         getInstanceAdmin(instance: any): any;
     };
     updater: {
-        initInstanceAdmin(instance: any, instanceAdmin: any): Promise<any>;
-        deleteInstanceAdmin(instance: any): any;
-    };
-} & import("@endo/eventual-send").RemotableBrand<{}, {
-    accessor: {
-        getPublicFacet(instance: any): any;
-        getBrands(instance: any): any;
-        getIssuers(instance: any): any;
-        getTerms(instance: any): any;
-        getOfferFilter(instance: any): any;
-        getInstallation(instance: any): any;
-        getInstanceAdmin(instance: any): any;
-    };
-    updater: {
-        initInstanceAdmin(instance: any, instanceAdmin: any): Promise<any>;
-        deleteInstanceAdmin(instance: any): any;
+        initInstanceAdmin(instance: any, instanceAdmin: any): Promise<void>;
+        deleteInstanceAdmin(instance: any): void;
     };
 }>;
-export function makeInstanceAdminMaker(zoeBaggage: MapStore<string, unknown>, seatHandleToZoeSeatAdmin: WeakMapStore<SeatHandle, ZoeSeatAdmin>): (instanceHandle: any, zoeInstanceStorageManager: any, adminNode: any) => import("@agoric/vat-data/src/types.js").KindFacet<{
+export function makeInstanceAdminMaker(zoeBaggage: import("@agoric/vat-data").Baggage, seatHandleToZoeSeatAdmin: WeakMapStore<SeatHandle, ZoeSeatAdmin>): (instanceHandle: any, zoeInstanceStorageManager: any, adminNode: any) => import("@agoric/swingset-liveslots").KindFacet<{
     getPublicFacet: ({ state }: {
         state: any;
     }) => any;
@@ -66,39 +52,33 @@ export function makeInstanceAdminMaker(zoeBaggage: MapStore<string, unknown>, se
         facets: {
             helper: any;
         };
-    }, invitationHandle: any, initialAllocation: any, proposal: any, offerArgs?: undefined) => {
-        getProposal(): Promise<ProposalRecord>;
-        getPayouts(): Promise<{}>;
+    }, invitationHandle: any, initialAllocation: any, proposal: any, offerArgs?: undefined) => import("@endo/exo").Guarded<{
+        getProposal(): Promise<any>;
+        getPayouts(): Promise<any>;
         getPayout(keyword: any): Promise<any>;
         getOfferResult(): Promise<any>;
-        hasExited(): Promise<boolean>;
-        tryExit(): Promise<void>;
-        numWantsSatisfied(): Promise<0 | 1>;
-        getExitSubscriber(): {
-            subscribeAfter(publishCount?: bigint): Promise<any>;
-            getUpdateSince(updateCount: any): any;
-        };
-        getFinalAllocation(): Promise<AmountKeywordRecord>;
-    };
+        hasExited(): Promise<any>;
+        tryExit(): Promise<any>;
+        numWantsSatisfied(): Promise<any>;
+        getExitSubscriber(): any;
+        getFinalAllocation(): any;
+    }>;
     makeNoEscrowSeat: ({ state, facets: { helper } }: {
         state: any;
         facets: {
             helper: any;
         };
-    }, initialAllocation: any, proposal: any, exitObj: any, seatHandle: any) => {
-        getProposal(): Promise<ProposalRecord>;
-        getPayouts(): Promise<{}>;
+    }, initialAllocation: any, proposal: any, exitObj: any, seatHandle: any) => import("@endo/exo").Guarded<{
+        getProposal(): Promise<any>;
+        getPayouts(): Promise<any>;
         getPayout(keyword: any): Promise<any>;
         getOfferResult(): Promise<any>;
-        hasExited(): Promise<boolean>;
-        tryExit(): Promise<void>;
-        numWantsSatisfied(): Promise<0 | 1>;
-        getExitSubscriber(): {
-            subscribeAfter(publishCount?: bigint): Promise<any>;
-            getUpdateSince(updateCount: any): any;
-        };
-        getFinalAllocation(): Promise<AmountKeywordRecord>;
-    };
+        hasExited(): Promise<any>;
+        tryExit(): Promise<any>;
+        numWantsSatisfied(): Promise<any>;
+        getExitSubscriber(): any;
+        getFinalAllocation(): any;
+    }>;
     getOfferFilter: ({ state }: {
         state: any;
     }) => any;

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

@@ -1 +1 @@
-{"version":3,"file":"instanceAdminStorage.d.ts","sourceRoot":"","sources":["instanceAdminStorage.js"],"names":[],"mappings":"AAmDO;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DN;AA0JM,wGAFI,aAAa,UAAU,EAAE,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwChD;6BAvDY,SAAS;IACrB,WAAe,EAAE,OAAO,CAAC;IACzB,eAAmB,EAAE,OAAO,CAAC;CAC1B,CAAC;2BACQ;IACZ,kBAAsB,EAAE,MAAM,EAAE,CAAC;CAC9B;oBACS,YAAY,GAAG,cAAc;4BAC7B;IACZ,KAAS,EAAE,KAAK,CAAC;CACd"}
+{"version":3,"file":"instanceAdminStorage.d.ts","sourceRoot":"","sources":["instanceAdminStorage.js"],"names":[],"mappings":"AAoDO,kDADK,OAAO,kBAAkB,EAAE,OAAO;;;;;;;;;;;;;;GA2D7C;AA0JM,mDAHI,OAAO,kBAAkB,EAAE,OAAO,4BAClC,YAAY,CAAC,UAAU,EAAE,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwChD;6BAvDY,QAAQ,CAAC;IACrB,WAAe,EAAE,OAAO,CAAC;IACzB,eAAmB,EAAE,OAAO,CAAC;CAC1B,CAAC;2BACQ;IACZ,kBAAsB,EAAE,MAAM,EAAE,CAAC;CAC9B;oBACS,YAAY,GAAG,cAAc;4BAC7B;IACZ,KAAS,EAAE,KAAK,CAAC;CACd"}

package/src/zoeService/instanceAdminStorage.js

@@ -1,3 +1,4 @@
+/* eslint @typescript-eslint/no-floating-promises: "warn" */
 import {
   canBeDurable,
   makeScalarBigSetStore,

package/src/zoeService/internal-types.d.ts

@@ -24,21 +24,21 @@ type DeleteInstanceAdmin = (instance: Instance) => void;
  * Assert the installation is known, and return the bundle/bundlecap and
  * installation
  */
-type UnwrapInstallation = (installationP: ERef<Installation>) => ERef<{
+type UnwrapInstallation = (installationP: ERef<Installation>) => globalThis.ERef<{
     bundle?: SourceBundle;
-    bundleCap?: BundleCap;
-    bundleID?: BundleID;
+    bundleCap?: any;
+    bundleID?: string | undefined;
     installation: Installation;
 }>;
 type GetIssuerRecords = () => IssuerRecords;
 type ZoeInstanceStorageManager = {
-    getTerms: InstanceStateGetTerms;
-    getIssuers: InstanceRecordGetIssuers;
-    getBrands: InstanceRecordGetBrands;
-    saveIssuer: SaveIssuer;
+    getTerms: () => AnyTerms;
+    getIssuers: () => IssuerKeywordRecord;
+    getBrands: () => BrandKeywordRecord;
+    saveIssuer: ZCF["saveIssuer"];
     makeZoeMint: MakeZoeMint;
     registerFeeMint: RegisterFeeMint;
-    getInstanceRecord: GetInstanceRecord;
+    getInstanceRecord: () => InstanceRecord;
     getIssuerRecords: GetIssuerRecords;
     initInstanceAdmin: InitInstanceAdmin;
     deleteInstanceAdmin: DeleteInstanceAdmin;
@@ -51,7 +51,7 @@ type ZoeInstanceStorageManager = {
     /**
      * of CreateVatResults
      */
-    getAdminNode: () => import('@agoric/swingset-vat').VatAdminFacet;
+    getAdminNode: () => import("@agoric/swingset-vat").VatAdminFacet;
 };
 /**
  * Create a storage manager for a particular contract instance. The
@@ -59,21 +59,21 @@ type ZoeInstanceStorageManager = {
  * issuerStorage and escrowStorage from Zoe, and stores the
  * instance-specific terms
  */
-type MakeZoeInstanceStorageManager = (instanceBaggage: MapStore<string, unknown>, installation: Installation, customTerms: object, uncleanIssuerKeywordRecord: IssuerKeywordRecord, instance: Instance, contractBundleCap: BundleCap, instanceLabel: string) => Promise<ZoeInstanceStorageManager>;
-type GetBundleCapForID = (id: BundleID) => Promise<BundleCap>;
+type MakeZoeInstanceStorageManager = (instanceBaggage: import("@agoric/vat-data").Baggage, installation: Installation, customTerms: object, uncleanIssuerKeywordRecord: IssuerKeywordRecord, instance: Instance, contractBundleCap: any, instanceLabel: string) => Promise<ZoeInstanceStorageManager>;
+type GetBundleCapForID = (id: string) => Promise<any>;
 type GetProposalShapeForInvitation = (invitationHandle: InvitationHandle) => Pattern | undefined;
 type ZoeStorageManager = {
     makeZoeInstanceStorageManager: MakeZoeInstanceStorageManager;
     getAssetKindByBrand: GetAssetKindByBrand;
     depositPayments: DepositPayments;
-    invitationIssuer: Issuer<'set'>;
+    invitationIssuer: Issuer<"set">;
     installBundle: InstallBundle;
     installBundleID: InstallBundleID;
     getBundleIDFromInstallation: GetBundleIDFromInstallation;
-    getPublicFacet: import('./utils.js').GetPublicFacet;
+    getPublicFacet: import("./utils.js").GetPublicFacet;
     getBrands: GetBrands;
     getIssuers: GetIssuers;
-    getTerms: import('./utils').GetTerms;
+    getTerms: import("./utils.js").GetTerms;
     getOfferFilter: GetOfferFilter;
     setOfferFilter: SetOfferFilter;
     getInstallationForInstance: GetInstallationForInstance;
@@ -85,6 +85,6 @@ type ZoeStorageManager = {
  * Use VatAdminSvc to create a new vat, but only with the code of the
  * ZCF bundle
  */
-type CreateZCFVat = (contractBundleCap: BundleCap, contractLabel: string) => Promise<import('@agoric/swingset-vat').CreateVatResults>;
-type GetFeeIssuerKit = (feeMintAccess: FeeMintAccess) => IssuerKit<'nat'>;
+type CreateZCFVat = (contractBundleCap: any, contractLabel: string) => Promise<import("@agoric/swingset-vat").CreateVatResults>;
+type GetFeeIssuerKit = (feeMintAccess: FeeMintAccess) => IssuerKit<"nat">;
 //# sourceMappingURL=internal-types.d.ts.map

package/src/zoeService/internal-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internal-types.d.ts","sourceRoot":"","sources":["internal-types.js"],"names":[],"mappings":";;;4BAMW,MAAM,SACN,KAAK,KACH,KAAK,IAAI,CAAC;;;;;;;;kCAWZ,MAAM,SACN,KAAK,KACH,KAAK;;;;;;;kCAUP,cAAc,YACd,qBAAqB,KACnB,QAAQ,UAAU,CAAC;oCAKrB,QAAQ,iBACR,aAAa,KACX,IAAI;mCAKN,QAAQ,KACN,aAAa;sCAKf,QAAQ,KACN,IAAI;;;;;0CASN,KAAK,YAAY,CAAC,KAChB,KAAK;IACjB,MAAU,CAAC,EAAE,YAAY,CAAC;IAC1B,SAAa,CAAC,EAAE,SAAS,CAAC;IAC1B,QAAY,CAAC,EAAE,QAAQ,CAAC;IACxB,YAAgB,EAAC,YAAY,CAAA;CAC1B,CAAC;;;cAWS,qBAAqB;gBACrB,wBAAwB;eACxB,uBAAuB;gBACvB,UAAU;iBACV,WAAW;qBACX,eAAe;uBACf,iBAAiB;sBACjB,gBAAgB;uBAChB,iBAAiB;yBACjB,mBAAmB;oBACnB,8BAA8B;yBAC9B,MAAM,MAAM;;;;aACZ,MAAM,MAAM;;;;kBACZ,MAAM,OAAO,sBAAsB,EAAE,aAAa;;;;;;;;gGAWrD,YAAY,eACZ,MAAM,8BACN,mBAAmB,YACnB,QAAQ,qBACR,SAAS,iBACT,MAAM,KACJ,QAAQ,yBAAyB,CAAC;8BAKpC,QAAQ,KACN,QAAQ,SAAS,CAAC;wDAKpB,gBAAgB,KACd,OAAO,GAAG,SAAS;;mCAKlB,6BAA6B;yBAC7B,mBAAmB;qBACnB,eAAe;sBACf,OAAO,KAAK,CAAC;mBACb,aAAa;qBACb,eAAe;iCACf,2BAA2B;oBAC3B,OAAO,YAAY,EAAE,cAAc;eACnC,SAAS;gBACT,UAAU;cACV,OAAO,SAAS,EAAE,QAAQ;oBAC1B,cAAc;oBACd,cAAc;gCACd,0BAA0B;sBAC1B,gBAAgB;wBAChB,kBAAkB;mCAClB,6BAA6B;;;;;;wCAQhC,SAAS,iBACT,MAAM,KACJ,QAAQ,OAAO,sBAAsB,EAAE,gBAAgB,CAAC;uCAK1D,aAAa,KACX,UAAU,KAAK,CAAC"}
+{"version":3,"file":"internal-types.d.ts","sourceRoot":"","sources":["internal-types.js"],"names":[],"mappings":";;;4BAMW,MAAM,SACN,KAAK,KACH,IAAI,CAAC,IAAI,CAAC;;;;;;;;kCAWZ,MAAM,SACN,KAAK,KACH,KAAK;;;;;;;kCAUP,cAAc,YACd,qBAAqB,KACnB,OAAO,CAAC,UAAU,CAAC;oCAKrB,QAAQ,iBACR,aAAa,KACX,IAAI;mCAKN,QAAQ,KACN,aAAa;sCAKf,QAAQ,KACN,IAAI;;;;;0CASN,IAAI,CAAC,YAAY,CAAC;aAEf,YAAY;;;kBAGR,YAAY;;8BAOjB,aAAa;;cAKZ,MAAM,QAAQ;gBACd,MAAM,mBAAmB;eACzB,MAAM,kBAAkB;gBACxB,GAAG,CAAC,YAAY,CAAC;iBACjB,WAAW;qBACX,eAAe;uBACf,MAAM,cAAc;sBACpB,gBAAgB;uBAChB,iBAAiB;yBACjB,mBAAmB;oBACnB,8BAA8B;yBAC9B,MAAM,MAAM;;;;aACZ,MAAM,MAAM;;;;kBACZ,MAAM,OAAO,sBAAsB,EAAE,aAAa;;;;;;;;uDAUrD,OAAO,kBAAkB,EAAE,OAAO,gBAClC,YAAY,eACZ,MAAM,8BACN,mBAAmB,YACnB,QAAQ,yCAER,MAAM,KACJ,OAAO,CAAC,yBAAyB,CAAC;;wDAWpC,gBAAgB,KACd,OAAO,GAAG,SAAS;;mCAKlB,6BAA6B;yBAC7B,mBAAmB;qBACnB,eAAe;sBACf,MAAM,CAAC,KAAK,CAAC;mBACb,aAAa;qBACb,eAAe;iCACf,2BAA2B;oBAC3B,OAAO,YAAY,EAAE,cAAc;eACnC,SAAS;gBACT,UAAU;cACV,OAAO,YAAY,EAAE,QAAQ;oBAC7B,cAAc;oBACd,cAAc;gCACd,0BAA0B;sBAC1B,gBAAgB;wBAChB,kBAAkB;mCAClB,6BAA6B;;;;;;4DAShC,MAAM,KACJ,OAAO,CAAC,OAAO,sBAAsB,EAAE,gBAAgB,CAAC;uCAK1D,aAAa,KACX,SAAS,CAAC,KAAK,CAAC"}

package/src/zoeService/internal-types.js

@@ -76,13 +76,13 @@
 
 /**
  * @typedef {object} ZoeInstanceStorageManager
- * @property {InstanceStateGetTerms} getTerms
- * @property {InstanceRecordGetIssuers} getIssuers
- * @property {InstanceRecordGetBrands} getBrands
- * @property {SaveIssuer} saveIssuer
+ * @property {() => AnyTerms} getTerms
+ * @property {() => IssuerKeywordRecord} getIssuers
+ * @property {() => BrandKeywordRecord} getBrands
+ * @property {ZCF['saveIssuer']} saveIssuer
  * @property {MakeZoeMint} makeZoeMint
  * @property {RegisterFeeMint} registerFeeMint
- * @property {GetInstanceRecord} getInstanceRecord
+ * @property {() => InstanceRecord} getInstanceRecord
  * @property {GetIssuerRecords} getIssuerRecords
  * @property {InitInstanceAdmin} initInstanceAdmin
  * @property {DeleteInstanceAdmin} deleteInstanceAdmin
@@ -133,7 +133,7 @@
  * @property {import('./utils.js').GetPublicFacet} getPublicFacet
  * @property {GetBrands} getBrands
  * @property {GetIssuers} getIssuers
- * @property {import('./utils').GetTerms} getTerms
+ * @property {import('./utils.js').GetTerms} getTerms
  * @property {GetOfferFilter} getOfferFilter
  * @property {SetOfferFilter} setOfferFilter
  * @property {GetInstallationForInstance} getInstallationForInstance

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

@@ -1 +1 @@
-{"version":3,"file":"invitationQueries.d.ts","sourceRoot":"","sources":["invitationQueries.js"],"names":[],"mappings":"AAKO;;;;EA6BN"}
+{"version":3,"file":"invitationQueries.d.ts","sourceRoot":"","sources":["invitationQueries.js"],"names":[],"mappings":"AAKO;;;;EA+BN"}

package/src/zoeService/invitationQueries.js

@@ -1,6 +1,6 @@
 // @jessie-check
 
-import { assert, details as X } from '@agoric/assert';
+import { assert, details as X, Fail, quote as q } from '@agoric/assert';
 import { E } from '@endo/eventual-send';
 
 export const makeInvitationQueryFns = invitationIssuer => {
@@ -13,10 +13,12 @@ export const makeInvitationQueryFns = invitationIssuer => {
       assert.note(err, X`Due to ${reason}`);
       throw err;
     };
-    return E.get(
-      E.get(E(invitationIssuer).getAmountOf(invitationP).catch(onRejected))
-        .value,
-    )[0];
+    const invAmount = await E(invitationIssuer)
+      .getAmountOf(invitationP)
+      .catch(onRejected);
+    (Array.isArray(invAmount.value) && invAmount.value.length === 1) ||
+      Fail`Expected exactly 1 invitation, not ${q(invAmount.value.length)}`;
+    return invAmount.value[0];
   };
 
   /** @type {GetInstance} */

package/src/zoeService/makeInvitation.d.ts

@@ -1,5 +1,5 @@
-export function prepareInvitationKit(baggage: MapStore<string, unknown>, shutdownZoeVat?: ShutdownWithFailure | undefined): {
-    invitationIssuer: Issuer<"set">;
-    invitationKit: IssuerKit<"set">;
+export function prepareInvitationKit(baggage: import("@agoric/vat-data").Baggage, shutdownZoeVat?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined): {
+    invitationIssuer: globalThis.Issuer<"set", InvitationDetails>;
+    invitationKit: globalThis.IssuerKit<"set", InvitationDetails>;
 };
 //# sourceMappingURL=makeInvitation.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"makeInvitation.d.ts","sourceRoot":"","sources":["makeInvitation.js"],"names":[],"mappings":"AAgBO,0FAFI,mBAAmB,GAAG,SAAS;;;EA4BzC"}
+{"version":3,"file":"makeInvitation.d.ts","sourceRoot":"","sources":["makeInvitation.js"],"names":[],"mappings":"AAgBO,8CAHI,OAAO,kBAAkB,EAAE,OAAO,mBAClC,OAAO,sBAAsB,EAAE,mBAAmB,GAAG,SAAS;;;EAgCxE"}

package/src/zoeService/makeInvitation.js

@@ -1,41 +1,45 @@
 // @jessie-check
 
+import { Fail, q } from '@agoric/assert';
 import { provideDurableMapStore } from '@agoric/vat-data';
-import {
-  AssetKind,
-  makeDurableIssuerKit,
-  prepareIssuerKit,
-} from '@agoric/ertp';
+import { AssetKind, hasIssuer, prepareIssuerKit } from '@agoric/ertp';
 import { InvitationElementShape } from '../typeGuards.js';
 
+/**
+ * Not deprecated because the first use below is still correct.
+ */
 const ZOE_INVITATION_KIT = 'ZoeInvitationKit';
 
 /**
  * @param {import('@agoric/vat-data').Baggage} baggage
- * @param {ShutdownWithFailure | undefined} shutdownZoeVat
+ * @param {import('@agoric/swingset-vat').ShutdownWithFailure | undefined} shutdownZoeVat
  */
 export const prepareInvitationKit = (baggage, shutdownZoeVat = undefined) => {
-  /** @type {IssuerKit<'set'> | undefined} */
-  let invitationKit;
-
   const invitationKitBaggage = provideDurableMapStore(
     baggage,
     ZOE_INVITATION_KIT,
   );
-  if (!invitationKitBaggage.has(ZOE_INVITATION_KIT)) {
-    invitationKit = makeDurableIssuerKit(
-      invitationKitBaggage,
-      'Zoe Invitation',
-      AssetKind.SET,
-      undefined,
-      shutdownZoeVat,
-      { elementShape: InvitationElementShape },
-    );
-    invitationKitBaggage.init(ZOE_INVITATION_KIT, invitationKit);
-  } else {
-    invitationKit = prepareIssuerKit(invitationKitBaggage);
+  if (invitationKitBaggage.has(ZOE_INVITATION_KIT)) {
+    // This legacy second use of ZOE_INVITATION_KIT is unneeded.
+    hasIssuer(invitationKitBaggage) ||
+      Fail`Legacy use of ${q(
+        ZOE_INVITATION_KIT,
+      )} must be redundant with normal storing of issuerKit in issuerBaggage`;
+    // Upgrade this legacy state by simply deleting it.
+    invitationKitBaggage.delete(ZOE_INVITATION_KIT);
   }
 
+  /** @type {IssuerKit<'set', InvitationDetails>} */
+  // @ts-expect-error cast
+  const invitationKit = prepareIssuerKit(
+    invitationKitBaggage,
+    'Zoe Invitation',
+    AssetKind.SET,
+    undefined,
+    shutdownZoeVat,
+    { elementShape: InvitationElementShape },
+  );
+
   return harden({
     invitationIssuer: invitationKit.issuer,
     invitationKit,

package/src/zoeService/offer/burnInvitation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"burnInvitation.d.ts","sourceRoot":"","sources":["burnInvitation.js"],"names":[],"mappings":"AAgBO,iDAPI,MAAM,cACN,KAAK,OAAO,CAAC,GACX,QAAQ;IACpB,cAAkB,EAAE,QAAQ,CAAC;IAC7B,gBAAoB,EAAE,gBAAgB,CAAC;CACpC,CAAC,CA4BJ"}
+{"version":3,"file":"burnInvitation.d.ts","sourceRoot":"","sources":["burnInvitation.js"],"names":[],"mappings":"AAgBO,iDAPI,MAAM,cACN,IAAI,CAAC,OAAO,CAAC,GACX,OAAO,CAAC;IACpB,cAAkB,EAAE,QAAQ,CAAC;IAC7B,gBAAoB,EAAE,gBAAgB,CAAC;CACpC,CAAC,CA4BJ"}

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

@@ -1 +1 @@
-{"version":3,"file":"offer.d.ts","sourceRoot":"","sources":["offer.js"],"names":[],"mappings":"AAgBO,6DA2DN"}
+{"version":3,"file":"offer.d.ts","sourceRoot":"","sources":["offer.js"],"names":[],"mappings":"AAcO,6DA0DN"}

package/src/zoeService/offer/offer.js

@@ -8,8 +8,6 @@ import { cleanProposal } from '../../cleanProposal.js';
 import { burnInvitation } from './burnInvitation.js';
 import { makeInvitationQueryFns } from '../invitationQueries.js';
 
-import '@agoric/ertp/exported.js';
-import '@agoric/store/exported.js';
 import '../internal-types.js';
 
 const { quote: q, Fail } = assert;
@@ -24,9 +22,8 @@ export const makeOfferMethod = offerDataAccess => {
   ) => {
     const invitationIssuer = offerDataAccess.getInvitationIssuer();
     const query = makeInvitationQueryFns(invitationIssuer);
-    const { instance, description } = await query.getInvitationDetails(
-      invitation,
-    );
+    const { instance, description } =
+      await query.getInvitationDetails(invitation);
     // AWAIT ///
 
     const instanceAdmin = await offerDataAccess.getInstanceAdmin(instance);

package/src/zoeService/originalZoeSeat.d.ts

@@ -0,0 +1,34 @@
+export namespace coreUserSeatMethods {
+    let getProposal: import("@endo/patterns").MethodGuard;
+    let getPayouts: import("@endo/patterns").MethodGuard;
+    let getPayout: import("@endo/patterns").MethodGuard;
+    let getOfferResult: import("@endo/patterns").MethodGuard;
+    let hasExited: import("@endo/patterns").MethodGuard;
+    let numWantsSatisfied: import("@endo/patterns").MethodGuard;
+    let getFinalAllocation: import("@endo/patterns").MethodGuard;
+    let getExitSubscriber: import("@endo/patterns").MethodGuard;
+}
+export const ZoeUserSeatShape: import("@endo/patterns").InterfaceGuard<{
+    tryExit: import("@endo/patterns").MethodGuard;
+    getProposal: import("@endo/patterns").MethodGuard;
+    getPayouts: import("@endo/patterns").MethodGuard;
+    getPayout: import("@endo/patterns").MethodGuard;
+    getOfferResult: import("@endo/patterns").MethodGuard;
+    hasExited: import("@endo/patterns").MethodGuard;
+    numWantsSatisfied: import("@endo/patterns").MethodGuard;
+    getFinalAllocation: import("@endo/patterns").MethodGuard;
+    getExitSubscriber: import("@endo/patterns").MethodGuard;
+}>;
+export namespace OriginalZoeSeatIKit {
+    export let zoeSeatAdmin: import("@endo/patterns").InterfaceGuard<{
+        replaceAllocation: import("@endo/patterns").MethodGuard;
+        exit: import("@endo/patterns").MethodGuard;
+        fail: import("@endo/patterns").MethodGuard;
+        resolveExitAndResult: import("@endo/patterns").MethodGuard;
+        getExitSubscriber: import("@endo/patterns").MethodGuard;
+        finalPayouts: import("@endo/patterns").MethodGuard;
+    }>;
+    export { ZoeUserSeatShape as userSeat };
+}
+export function declareOldZoeSeatAdminKind(baggage: import("@agoric/vat-data").Baggage, makeDurablePublishKit: () => PublishKit<any>): void;
+//# sourceMappingURL=originalZoeSeat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"originalZoeSeat.d.ts","sourceRoot":"","sources":["originalZoeSeat.js"],"names":[],"mappings":";;;;;;;;;;AA8BA;;;;;;;;;;GAGG;;;;;;;;;;;;AA+CI,oDAHI,OAAO,kBAAkB,EAAE,OAAO,yBAClC,MAAM,UAAU,CAAC,GAAG,CAAC,QAkR/B"}