@agoric/zoe 0.26.2 → 0.26.3-calypso-dev-84eb287.0

package/src/zoeService/escrowStorage.d.ts

@@ -1,4 +1,4 @@
-export function provideEscrowStorage(baggage: MapStore<string, unknown>): {
+export function provideEscrowStorage(baggage: import("@agoric/vat-data").Baggage): {
     createPurse: CreatePurse;
     provideLocalPurse: ProvideLocalPurse;
     withdrawPayments: WithdrawPayments;

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

@@ -1 +1 @@
-{"version":3,"file":"escrowStorage.d.ts","sourceRoot":"","sources":["escrowStorage.js"],"names":[],"mappings":"AAkBO;;;;;EAkHN"}
+{"version":3,"file":"escrowStorage.d.ts","sourceRoot":"","sources":["escrowStorage.js"],"names":[],"mappings":"AAiBO,8CAFI,OAAO,kBAAkB,EAAE,OAAO;;;;;EA8G5C"}

package/src/zoeService/escrowStorage.js

@@ -1,14 +1,13 @@
 import { AmountMath } from '@agoric/ertp';
 import { E } from '@endo/eventual-send';
 import { q, Fail } from '@agoric/assert';
-import { objectMap } from '@agoric/internal';
+import { deeplyFulfilledObject, objectMap } from '@agoric/internal';
 import { provideDurableWeakMapStore } from '@agoric/vat-data';
 
-import './types.js';
+/// <reference path="./types.js" />
 import './internal-types.js';
 
 import { cleanKeywords } from '../cleanProposal.js';
-import { arrayToObj } from '../objArrayConversion.js';
 
 /**
  * Store the pool purses whose purpose is to escrow assets, with one
@@ -17,7 +16,7 @@ import { arrayToObj } from '../objArrayConversion.js';
  * @param {import('@agoric/vat-data').Baggage} baggage
  */
 export const provideEscrowStorage = baggage => {
-  /** @type {WeakMapStore<Brand, ERef<Purse>>} */
+  /** @type {WeakMapStore<Brand, Purse>} */
   const brandToPurse = provideDurableWeakMapStore(baggage, 'brandToPurse');
 
   /** @type {CreatePurse} */
@@ -76,7 +75,6 @@ export const provideEscrowStorage = baggage => {
   const depositPayments = async (proposal, payments) => {
     const { give, want } = proposal;
     const giveKeywords = Object.keys(give);
-    const wantKeywords = Object.keys(want);
     const paymentKeywords = cleanKeywords(payments);
 
     // Assert that all of the payment keywords are present in the give
@@ -91,35 +89,30 @@ export const provideEscrowStorage = baggage => {
         )}`;
     });
 
-    const proposalKeywords = harden([...giveKeywords, ...wantKeywords]);
-
-    // If any of these deposits hang or fail, then depositPayments
+    // If any of these deposits hang or fail, then this `await` also
     // hangs or fails, the offer does not succeed, and any funds that
     // were deposited into the pool purses are lost. We have a ticket
     // for giving the user a refund of what was already deposited, and
     // offer safety and payout liveness are still meaningful as long
     // as issuers are well-behaved. For more, see
     // https://github.com/Agoric/agoric-sdk/issues/1271
-    const amountsDeposited = await Promise.all(
-      giveKeywords.map(keyword => {
-        payments[keyword] !== undefined ||
-          Fail`The ${q(
-            keyword,
-          )} keyword in proposal.give did not have an associated payment in the paymentKeywordRecord, which had keywords: ${q(
-            paymentKeywords,
-          )}`;
-        return doDepositPayment(payments[keyword], give[keyword]);
-      }),
-    );
-
-    const emptyAmountsForWantKeywords = wantKeywords.map(keyword =>
-      AmountMath.makeEmptyFromAmount(want[keyword]),
-    );
+    const depositPs = objectMap(give, (amount, keyword) => {
+      payments[keyword] !== undefined ||
+        Fail`The ${q(
+          keyword,
+        )} keyword in proposal.give did not have an associated payment in the paymentKeywordRecord, which had keywords: ${q(
+          paymentKeywords,
+        )}`;
+      return doDepositPayment(payments[keyword], amount);
+    });
+    const deposits = await deeplyFulfilledObject(depositPs);
 
-    const initialAllocation = arrayToObj(
-      [...amountsDeposited, ...emptyAmountsForWantKeywords],
-      proposalKeywords,
-    );
+    const initialAllocation = harden({
+      ...objectMap(want, amount => AmountMath.makeEmptyFromAmount(amount)),
+      // Deposits should win in case of overlapping give/want keywords
+      // (which are not allowed as of 2024-01).
+      ...deposits,
+    });
 
     return initialAllocation;
   };

package/src/zoeService/feeMint.d.ts

@@ -1,29 +1,22 @@
 export namespace defaultFeeIssuerConfig {
-    const name: "ZDEFAULT";
-    const assetKind: "nat";
+    let name: "ZDEFAULT";
+    let assetKind: "nat";
     namespace displayInfo {
-        export const decimalPlaces: number;
-        const assetKind_1: "nat";
+        export let decimalPlaces: number;
+        let assetKind_1: "nat";
         export { assetKind_1 as assetKind };
     }
 }
 /**
  * @param {import('@agoric/vat-data').Baggage} zoeBaggage
  * @param {FeeIssuerConfig} feeIssuerConfig
- * @param {ShutdownWithFailure} shutdownZoeVat
+ * @param {import('@agoric/swingset-vat').ShutdownWithFailure} shutdownZoeVat
  */
-export function prepareFeeMint(zoeBaggage: MapStore<string, unknown>, feeIssuerConfig: FeeIssuerConfig, shutdownZoeVat: ShutdownWithFailure): {
+export function prepareFeeMint(zoeBaggage: import("@agoric/vat-data").Baggage, feeIssuerConfig: FeeIssuerConfig, shutdownZoeVat: import("@agoric/swingset-vat").ShutdownWithFailure): import("@endo/exo").GuardedKit<{
     feeMint: {
-        getFeeIssuerKit(allegedFeeMintAccess: any): any;
-        getFeeIssuer(): any;
-        getFeeBrand(): any;
-    };
-    feeMintAccess: {};
-} & import("@endo/eventual-send").RemotableBrand<{}, {
-    feeMint: {
-        getFeeIssuerKit(allegedFeeMintAccess: any): any;
-        getFeeIssuer(): any;
-        getFeeBrand(): any;
+        getFeeIssuerKit(allegedFeeMintAccess: any): globalThis.IssuerKit<"nat">;
+        getFeeIssuer(): globalThis.Issuer<"nat", import("@endo/patterns").Key>;
+        getFeeBrand(): globalThis.Brand<"nat">;
     };
     feeMintAccess: {};
 }>;

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

@@ -1 +1 @@
-{"version":3,"file":"feeMint.d.ts","sourceRoot":"","sources":["feeMint.js"],"names":[],"mappings":";;;;;;;;;AA2BA;;;;GAIG;AACH,uFAHW,eAAe,kBACf,mBAAmB;;;;;;;;;;;;;;GAsD7B"}
+{"version":3,"file":"feeMint.d.ts","sourceRoot":"","sources":["feeMint.js"],"names":[],"mappings":";;;;;;;;;AA4BA;;;;GAIG;AACH,2CAJW,OAAO,kBAAkB,EAAE,OAAO,mBAClC,eAAe,kBACf,OAAO,sBAAsB,EAAE,mBAAmB;;;;;;;GA2D5D"}

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,cACjB,OAAO;;;;;;;;;;;;;;;GA+IjB;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,
@@ -177,7 +178,7 @@ const makeInstanceAdminBehavior = (zoeBaggage, makeZoeSeatAdminKit) => {
 
       state.zoeSeatAdmins.add(zoeSeatAdmin);
       state.handleOfferObj || Fail`incomplete setup of zoe seat`;
-      E.when(
+      void E.when(
         E(state.handleOfferObj).handleOffer(invitationHandle, seatData),
         /** @param {HandleOfferResult} result */
         result => zoeSeatAdmin.resolveExitAndResult(result),

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

@@ -32,13 +32,13 @@ type UnwrapInstallation = (installationP: ERef<Installation>) => ERef<{
 }>;
 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 MakeZoeInstanceStorageManager = (instanceBaggage: import("@agoric/vat-data").Baggage, installation: Installation, customTerms: object, uncleanIssuerKeywordRecord: IssuerKeywordRecord, instance: Instance, contractBundleCap: BundleCap, instanceLabel: string) => Promise<ZoeInstanceStorageManager>;
 type GetBundleCapForID = (id: BundleID) => Promise<BundleCap>;
 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: BundleCap, 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,KAChB,IAAI,CAAC;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;8BAMQ,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,qBACR,SAAS,iBACT,MAAM,KACJ,OAAO,CAAC,yBAAyB,CAAC;8BAKpC,QAAQ,KACN,OAAO,CAAC,SAAS,CAAC;wDAKpB,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;;;;;;wCAQhC,SAAS,iBACT,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"}