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

package/src/zoeService/originalZoeSeat.js

@@ -0,0 +1,353 @@
+/* eslint @typescript-eslint/no-floating-promises: "warn" */
+import { SubscriberShape } 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-ambient.js';
+import '../internal-types.js';
+import {
+  AmountKeywordRecordShape,
+  KeywordShape,
+  ExitObjectShape,
+  PaymentPKeywordRecordShape,
+} from '../typeGuards.js';
+
+const { Fail } = assert;
+
+export const coreUserSeatMethods = harden({
+  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()),
+  numWantsSatisfied: M.call().returns(M.promise()),
+  getFinalAllocation: M.call().returns(M.promise()),
+  getExitSubscriber: M.call().returns(M.any()),
+});
+
+export const ZoeUserSeatShape = M.interface('UserSeat', {
+  ...coreUserSeatMethods,
+  tryExit: M.call().returns(M.promise()),
+});
+
+export const OriginalZoeSeatIKit = 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: ZoeUserSeatShape,
+});
+
+const assertHasNotExited = (c, msg) => {
+  !c.state.instanceAdminHelper.hasExited(c.facets.zoeSeatAdmin) ||
+    assert(!c.state.instanceAdminHelper.hasExited(c.facets.zoeSeatAdmin), msg);
+};
+
+/**
+ * declareOldZoeSeatAdminKind declares an exo for the original kind of ZoeSeatKit.
+ * This version creates a reference cycle that garbage collection can't remove
+ * because it goes through weakMaps in two different Vats. We've defined a new
+ * Kind that doesn't have this problem, but we won't upgrade the existing
+ * objects, so the Kind must continue to be defined, but we don't return the
+ * maker function.
+ *
+ * The original ZoeSeatKit is an object that manages the state
+ * of a seat participating in a Zoe contract and return its two facets.
+ *
+ * The UserSeat is suitable to be handed to an agent outside zoe and the
+ * contract and allows them to query or monitor the current state, access the
+ * payouts and result, and call exit() if that's allowed for this seat.
+ *
+ * The zoeSeatAdmin is passed by Zoe to the ContractFacet (zcf), to allow zcf to
+ * query or update the allocation or exit the seat cleanly.
+ *
+ * @param {import('@agoric/vat-data').Baggage} baggage
+ * @param {() => PublishKit<any>} makeDurablePublishKit
+ */
+export const declareOldZoeSeatAdminKind = (baggage, makeDurablePublishKit) => {
+  const doExit = (
+    zoeSeatAdmin,
+    currentAllocation,
+    withdrawFacet,
+    instanceAdminHelper,
+  ) => {
+    /** @type {PaymentPKeywordRecord} */
+    const payouts = withdrawFacet.withdrawPayments(currentAllocation);
+    return E.when(
+      zoeSeatAdmin.finalPayouts(payouts),
+      () => instanceAdminHelper.exitZoeSeatAdmin(zoeSeatAdmin),
+      () => instanceAdminHelper.exitZoeSeatAdmin(zoeSeatAdmin),
+    );
+  };
+
+  // There is a race between resolveExitAndResult() and getOfferResult() that
+  // can be limited to when the adminFactory is paged in. If state.offerResult
+  // is defined, getOfferResult will return it. If it's not defined when
+  // getOfferResult is called, create a promiseKit, return the promise and store
+  // the kit here. When resolveExitAndResult() is called, it saves
+  // state.offerResult and resolves the promise if it exists, then removes the
+  // table entry.
+  /**
+   * @typedef {WeakMap<ZCFSeat, unknown>}
+   */
+  const ephemeralOfferResultStore = new WeakMap();
+
+  // notice that this returns a maker function which we drop on the floor.
+  prepareExoClassKit(
+    baggage,
+    'ZoeSeatKit',
+    OriginalZoeSeatIKit,
+    /**
+     *
+     * @param {Allocation} initialAllocation
+     * @param {ProposalRecord} proposal
+     * @param {InstanceAdminHelper} instanceAdminHelper
+     * @param {WithdrawFacet} withdrawFacet
+     * @param {ERef<ExitObj>} [exitObj]
+     * @param {boolean} [offerResultIsUndefined]
+     */
+    (
+      initialAllocation,
+      proposal,
+      instanceAdminHelper,
+      withdrawFacet,
+      exitObj = undefined,
+      // emptySeatKits start with offerResult validly undefined; others can set
+      // it to anything (including undefined) in resolveExitAndResult()
+      offerResultIsUndefined = false,
+    ) => {
+      const { publisher, subscriber } = makeDurablePublishKit();
+      return {
+        currentAllocation: initialAllocation,
+        proposal,
+        exitObj,
+        offerResult: /** @type {any} */ (undefined),
+        offerResultStored: offerResultIsUndefined,
+        instanceAdminHelper,
+        withdrawFacet,
+        publisher,
+        subscriber,
+        payouts: harden({}),
+        exiting: false,
+      };
+    },
+    {
+      zoeSeatAdmin: {
+        replaceAllocation(replacementAllocation) {
+          const { state } = this;
+          assertHasNotExited(
+            this,
+            'Cannot replace allocation. Seat has already exited',
+          );
+          harden(replacementAllocation);
+          // Merging happens in ZCF, so replacementAllocation can
+          // replace the old allocation entirely.
+
+          state.currentAllocation = replacementAllocation;
+        },
+        exit(completion) {
+          const { state, facets } = this;
+          // Since this method doesn't wait, we could re-enter via exitAllSeats.
+          // If that happens, we shouldn't re-do any of the work.
+          if (state.exiting) {
+            return;
+          }
+          assertHasNotExited(this, 'Cannot exit seat. Seat has already exited');
+
+          state.exiting = true;
+          E.when(
+            doExit(
+              facets.zoeSeatAdmin,
+              state.currentAllocation,
+              state.withdrawFacet,
+              state.instanceAdminHelper,
+            ),
+            () => state.publisher.finish(completion),
+          );
+        },
+        fail(reason) {
+          const { state, facets } = this;
+          // Since this method doesn't wait, we could re-enter via failAllSeats.
+          // If that happens, we shouldn't re-do any of the work.
+          if (state.exiting) {
+            return;
+          }
+
+          assertHasNotExited(this, 'Cannot fail seat. Seat has already exited');
+
+          state.exiting = true;
+          E.when(
+            doExit(
+              facets.zoeSeatAdmin,
+              state.currentAllocation,
+              state.withdrawFacet,
+              state.instanceAdminHelper,
+            ),
+            () => state.publisher.fail(reason),
+            () => state.publisher.fail(reason),
+          );
+        },
+        // called only for seats resulting from offers.
+        /** @param {HandleOfferResult} result */
+        resolveExitAndResult({ offerResultPromise, exitObj }) {
+          const { state, facets } = this;
+
+          !state.offerResultStored ||
+            Fail`offerResultStored before offerResultPromise`;
+
+          if (!ephemeralOfferResultStore.has(facets.userSeat)) {
+            // this was called before getOfferResult
+            const kit = makePromiseKit();
+            kit.resolve(offerResultPromise);
+            ephemeralOfferResultStore.set(facets.userSeat, kit);
+          }
+
+          const pKit = ephemeralOfferResultStore.get(facets.userSeat);
+          void E.when(
+            offerResultPromise,
+            offerResult => {
+              // Resolve the ephemeral promise for offerResult
+              pKit.resolve(offerResult);
+              // Now we want to store the offerResult in `state` to get it off the heap,
+              // but we need to handle three cases:
+              //   1. already durable. (This includes being a remote presence.)
+              //   2. has promises for durable objects.
+              //   3. not durable even after resolving promises.
+              // For #1 we can assign directly, but we deeply await to also handle #2.
+              void E.when(
+                deeplyFulfilled(offerResult),
+                fulfilledOfferResult => {
+                  try {
+                    // In cases 1-2 this assignment will succeed.
+                    state.offerResult = fulfilledOfferResult;
+                    // 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);
+                  } catch (err) {
+                    console.warn(
+                      'non-durable offer result will be lost upon zoe vat termination:',
+                      offerResult,
+                    );
+                  }
+                },
+                // no rejection handler because an offer result containing promises that reject
+                // is within spec
+              );
+            },
+            e => {
+              pKit.reject(e);
+              // NB: leave the rejected promise in the ephemeralOfferResultStore
+              // because it can't go in durable state
+            },
+          );
+
+          state.exitObj = exitObj;
+        },
+        getExitSubscriber() {
+          const { state } = this;
+          return state.subscriber;
+        },
+        async finalPayouts(payments) {
+          const { state } = this;
+
+          const settledPayouts = await deeplyFulfilled(payments);
+          state.payouts = settledPayouts;
+        },
+      },
+      userSeat: {
+        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.userSeat)) {
+            return ephemeralOfferResultStore.get(facets.userSeat).promise;
+          }
+
+          const kit = makePromiseKit();
+          ephemeralOfferResultStore.set(facets.userSeat, kit);
+          return kit.promise;
+        },
+        async hasExited() {
+          const { state, facets } = this;
+
+          return (
+            state.exiting ||
+            state.instanceAdminHelper.hasExited(facets.zoeSeatAdmin)
+          );
+        },
+        async tryExit() {
+          const { state } = this;
+          if (!state.exitObj)
+            throw Fail`exitObj must be initialized before use`;
+          assertHasNotExited(this, 'Cannot exit; seat has already exited');
+
+          return E(state.exitObj).exit();
+        },
+        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,
+          );
+        },
+      },
+    },
+  );
+};

package/src/zoeService/startInstance.d.ts

@@ -1,4 +1,4 @@
-export function makeStartInstance(startInstanceAccess: Pick<ZoeStorageManager, 'makeZoeInstanceStorageManager' | 'unwrapInstallation'>, getZcfBundleCapP: () => ERef<BundleCap>, getBundleCapByIdNow: (id: string) => BundleCap, zoeBaggage: MapStore<string, unknown>): import('./utils').StartInstance;
-export type Baggage = import('@agoric/vat-data').Baggage;
-export type BundleCap = import('@agoric/swingset-vat').BundleCap;
+export function makeStartInstance(startInstanceAccess: Pick<ZoeStorageManager, "makeZoeInstanceStorageManager" | "unwrapInstallation">, getZcfBundleCapP: () => ERef<BundleCap>, getBundleCapByIdNow: (id: string) => BundleCap, zoeBaggage: Baggage): import("./utils.js").StartInstance;
+export type BundleCap = import("@agoric/swingset-vat").BundleCap;
+import type { Baggage } from '@agoric/vat-data';
 //# sourceMappingURL=startInstance.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"startInstance.d.ts","sourceRoot":"","sources":["startInstance.js"],"names":[],"mappings":"AAiCO,uDANI,KAAK,iBAAiB,EAAE,+BAA+B,GAAG,oBAAoB,CAAC,oBAC/E,MAAM,KAAK,SAAS,CAAC,4BAChB,MAAM,KAAK,SAAS,0CAEvB,OAAO,SAAS,EAAE,aAAa,CAmW3C;sBA7Wa,OAAO,kBAAkB,EAAE,OAAO;wBACjC,OAAO,sBAAsB,EAAE,SAAS"}
+{"version":3,"file":"startInstance.d.ts","sourceRoot":"","sources":["startInstance.js"],"names":[],"mappings":"AAoCO,uDANI,IAAI,CAAC,iBAAiB,EAAE,+BAA+B,GAAG,oBAAoB,CAAC,oBAC/E,MAAM,IAAI,CAAC,SAAS,CAAC,uBACrB,CAAC,EAAE,EAAE,MAAM,KAAK,SAAS,wBAEvB,OAAO,YAAY,EAAE,aAAa,CAsW9C;wBA/Wc,OAAO,sBAAsB,EAAE,SAAS;6BAD5B,kBAAkB"}

package/src/zoeService/startInstance.js

@@ -1,3 +1,4 @@
+/* eslint @typescript-eslint/no-floating-promises: "warn" */
 import { E } from '@endo/eventual-send';
 import { passStyleOf } from '@endo/marshal';
 import {
@@ -19,7 +20,9 @@ import {
   InstanceAdminShape,
 } from '../typeGuards.js';
 
-/** @typedef {import('@agoric/vat-data').Baggage} Baggage */
+// import '../internal-types.js';
+
+/** @import {Baggage} from '@agoric/vat-data' */
 /** @typedef { import('@agoric/swingset-vat').BundleCap} BundleCap */
 
 const { Fail, quote: q } = assert;
@@ -29,7 +32,7 @@ const { Fail, quote: q } = assert;
  * @param {() => ERef<BundleCap>} getZcfBundleCapP
  * @param {(id: string) => BundleCap} getBundleCapByIdNow
  * @param {Baggage} zoeBaggage
- * @returns {import('./utils').StartInstance}
+ * @returns {import('./utils.js').StartInstance}
  */
 export const makeStartInstance = (
   startInstanceAccess,
@@ -63,7 +66,7 @@ export const makeStartInstance = (
     adminNode: M.remotable('adminNode'),
   });
 
-  /** @type {{ onFulfilled: (completion: any, instanceAdmin: InstanceAdmin) => void, onRejected: (reason: any, instanceAdmin: InstanceAdmin, adminNode: any) => void }} */
+  /** @type {import('@agoric/swingset-liveslots').PromiseWatcher<Completion, [InstanceAdmin, Handle<'adminNode'>]>} */
   const watcher = prepareExo(
     zoeBaggage,
     'InstanceCompletionWatcher',
@@ -95,7 +98,6 @@ export const makeStartInstance = (
   );
 
   const watchForAdminNodeDone = (adminNode, instAdmin) => {
-    // @ts-expect-error XXX unknown type?
     watchPromise(E(adminNode).done(), watcher, instAdmin, adminNode);
   };
 
@@ -258,13 +260,13 @@ export const makeStartInstance = (
       async upgradeContract(contractBundleId, newPrivateArgs = undefined) {
         const { state } = this;
 
-        const newContractBundleCap = await getBundleCapByIdNow(
-          contractBundleId,
-        );
+        const newContractBundleCap =
+          await getBundleCapByIdNow(contractBundleId);
         const vatParameters = {
           contractBundleCap: newContractBundleCap,
           privateArgs: newPrivateArgs,
         };
+        state.contractBundleCap = newContractBundleCap;
         return E.when(getFreshZcfBundleCap(), bCap =>
           E(state.adminNode).upgrade(bCap, { vatParameters }),
         );
@@ -272,16 +274,19 @@ export const makeStartInstance = (
     },
   );
 
+  /**
+   * @type {import('./utils.js').StartInstance}
+   */
   const startInstance = async (
     installationP,
     uncleanIssuerKeywordRecord = harden({}),
+    // @ts-expect-error FIXME may not match the expected terms of SF
     customTerms = harden({}),
     privateArgs = undefined,
     instanceLabel = '',
   ) => {
-    const { installation, bundle, bundleCap } = await E(
-      startInstanceAccess,
-    ).unwrapInstallation(installationP);
+    const { installation, bundle, bundleCap } =
+      await E(startInstanceAccess).unwrapInstallation(installationP);
     // AWAIT ///
 
     const contractBundleCap = bundle || bundleCap;
@@ -329,6 +334,7 @@ export const makeStartInstance = (
     void watchForAdminNodeDone(adminNode, instanceAdmin);
 
     /** @type {ZoeInstanceAdmin} */
+    // @ts-expect-error XXX saveIssuer
     const zoeInstanceAdminForZcf = makeZoeInstanceAdmin(
       zoeInstanceStorageManager,
       instanceAdmin,
@@ -354,6 +360,7 @@ export const makeStartInstance = (
 
     // creatorInvitation can be undefined, but if it is defined,
     // let's make sure it is an invitation.
+    // @ts-expect-error cast
     return E.when(
       Promise.all([
         creatorInvitationP,
@@ -382,6 +389,5 @@ export const makeStartInstance = (
       },
     );
   };
-  // @ts-expect-error cast
   return harden(startInstance);
 };

package/src/zoeService/{types.d.ts → types-ambient.d.ts}

@@ -23,12 +23,12 @@ type ZoeService = {
     getInvitationIssuer: GetInvitationIssuer;
     install: InstallBundle;
     installBundleID: InstallBundleID;
-    startInstance: import('./utils').StartInstance;
+    startInstance: import("./utils.js").StartInstance;
     offer: Offer;
-    getPublicFacet: import('./utils').GetPublicFacet;
+    getPublicFacet: import("./utils.js").GetPublicFacet;
     getIssuers: GetIssuers;
     getBrands: GetBrands;
-    getTerms: import('./utils').GetTerms;
+    getTerms: import("./utils.js").GetTerms;
     getOfferFilter: GetOfferFilter;
     getInstallationForInstance: GetInstallationForInstance;
     getInstance: GetInstance;
@@ -43,19 +43,19 @@ type ZoeService = {
     getBundleIDFromInstallation: GetBundleIDFromInstallation;
     getProposalShapeForInvitation: (invitationHandle: InvitationHandle) => Pattern | undefined;
 };
-type GetInvitationIssuer = () => Promise<Issuer<'set'>>;
-type GetFeeIssuer = () => Promise<Issuer<'nat'>>;
+type GetInvitationIssuer = () => Promise<Issuer<"set", InvitationDetails>>;
+type GetFeeIssuer = () => Promise<Issuer<"nat">>;
 type GetConfiguration = () => {
     feeIssuerConfig: FeeIssuerConfig;
 };
-type GetIssuers = (instance: import('./utils').Instance<any>) => Promise<IssuerKeywordRecord>;
-type GetBrands = (instance: import('./utils').Instance<any>) => Promise<BrandKeywordRecord>;
-type GetOfferFilter = (instance: import('./utils').Instance<any>) => string[];
+type GetIssuers = (instance: import("./utils.js").Instance<any>) => Promise<IssuerKeywordRecord>;
+type GetBrands = (instance: import("./utils.js").Instance<any>) => Promise<BrandKeywordRecord>;
+type GetOfferFilter = (instance: import("./utils.js").Instance<any>) => string[];
 type SetOfferFilter = (instance: Instance, strings: string[]) => any;
-type GetInstallationForInstance = (instance: import('./utils').Instance<any>) => Promise<Installation>;
-type GetInstance = (invitation: ERef<Invitation>) => Promise<import('./utils').Instance<any>>;
+type GetInstallationForInstance = (instance: import("./utils.js").Instance<any>) => Promise<Installation>;
+type GetInstance = (invitation: ERef<Invitation>) => Promise<import("./utils.js").Instance<any>>;
 type GetInstallation = (invitation: ERef<Invitation>) => Promise<Installation>;
-type GetInvitationDetails = (invitation: ERef<Invitation>) => Promise<InvitationDetails>;
+type GetInvitationDetails = (invitation: ERef<Invitation<any, any>>) => Promise<InvitationDetails>;
 /**
  * Create an installation by safely evaluating the code and
  * registering it with Zoe. Returns an installation.
@@ -64,12 +64,12 @@ type InstallBundle = (bundle: Bundle | SourceBundle, bundleLabel?: string | unde
 /**
  * Create an installation from a Bundle ID. Returns an installation.
  */
-type InstallBundleID = (bundleID: BundleID, bundleLabel?: string | undefined) => Promise<Installation>;
+type InstallBundleID = (bundleID: string, bundleLabel?: string | undefined) => Promise<Installation>;
 /**
  * Verify that an alleged Installation is real, and return the Bundle ID it
  * will use for contract code.
  */
-type GetBundleIDFromInstallation = (allegedInstallation: ERef<Installation>) => Promise<BundleID>;
+type GetBundleIDFromInstallation = (allegedInstallation: ERef<Installation>) => Promise<string>;
 /**
  * To redeem an invitation, the user normally provides a proposal (their
  * rules for the offer) as well as payments to be escrowed by Zoe.  If
@@ -85,7 +85,7 @@ type GetBundleIDFromInstallation = (allegedInstallation: ERef<Installation>) =>
  * values are the actual payments to be escrowed. A payment is
  * expected for every rule under `give`.
  */
-type Offer = <Args, Result>(invitation: ERef<Invitation<Result, Args>>, proposal?: Proposal, paymentKeywordRecord?: PaymentPKeywordRecord, offerArgs?: Args | undefined) => Promise<UserSeat<Result>>;
+type Offer = <Result, Args = undefined>(invitation: ERef<Invitation<Result, Args>>, proposal?: Proposal, paymentKeywordRecord?: PaymentPKeywordRecord, offerArgs?: Args) => Promise<UserSeat<Result>>;
 /**
  * Zoe uses seats to access or manipulate offers. They let contracts and users
  * interact with them. Zoe has two kinds of seats. ZCFSeats are used within
@@ -161,14 +161,10 @@ type ProposalRecord = {
  * { Asset: AmountMath.make(assetBrand, 5n), Price:
  * AmountMath.make(priceBrand, 9n) }
  */
-type AmountKeywordRecord = Record<Keyword, Amount<any>>;
+type AmountKeywordRecord = Record<Keyword, import("@agoric/ertp/src/types.js").AnyAmount>;
 type Waker = {
     wake: () => void;
 };
-type Deadline = import('@agoric/time/src/types').Timestamp;
-type Timer = {
-    setWakeup: (deadline: Deadline, wakerP: ERef<Waker>) => void;
-};
 type OnDemandExitRule = {
     onDemand: null;
 };
@@ -177,8 +173,8 @@ type WaivedExitRule = {
 };
 type AfterDeadlineExitRule = {
     afterDeadline: {
-        timer: Timer;
-        deadline: Deadline;
+        timer: import("@agoric/time").TimerService;
+        deadline: import("@agoric/time").Timestamp;
     };
 };
 /**
@@ -187,17 +183,16 @@ type AfterDeadlineExitRule = {
  * The possible records are:
  * `{ waived: null }`
  * `{ onDemand: null }`
- * `{ afterDeadline: { timer :Timer<Deadline>, deadline :Deadline } }
+ * `{ afterDeadline: { timer :Timer<Deadline>, deadline :Deadline } }`
  */
 type ExitRule = OnDemandExitRule | WaivedExitRule | AfterDeadlineExitRule;
-type Instance = import('./utils').Instance<any>;
-type VatAdminSvc = import('@agoric/swingset-vat').VatAdminSvc;
+type Instance = import("./utils.js").Instance<any>;
 type ZCFSpec = {
-    bundleCap: import('@agoric/swingset-vat').BundleCap;
+    bundleCap: import("@agoric/swingset-vat").BundleCap;
 } | {
     name: string;
 } | {
-    id: BundleID;
+    id: string;
 };
 /**
  * Opaque type for a JSONable source bundle
@@ -207,13 +202,13 @@ type PaymentPKeywordRecord = Record<Keyword, ERef<Payment<any>>>;
 type PaymentKeywordRecord = Record<Keyword, Payment<any>>;
 type InvitationDetails = {
     installation: Installation;
-    instance: import('./utils').Instance<any>;
+    instance: import("./utils.js").Instance<any>;
     handle: InvitationHandle;
     description: string;
     customDetails?: Record<string, any> | undefined;
 };
-type Installation<SF = any> = import('./utils').Installation<SF>;
-type InstallationStart<I extends Installation<any>> = import('./utils').InstallationStart<I>;
+type Installation<SF = any> = import("./utils.js").Installation<SF>;
+type InstallationStart<I extends Installation<any>> = import("./utils.js").InstallationStart<I>;
 type FeeIssuerConfig = {
     name: string;
     assetKind: AssetKind;
@@ -222,5 +217,5 @@ type FeeIssuerConfig = {
 type ZoeFeesConfig = {
     getPublicFacetFee: NatValue;
 };
-type FeeMintAccess = Handle<'feeMintAccess'>;
-//# sourceMappingURL=types.d.ts.map
+type FeeMintAccess = Handle<"feeMintAccess">;
+//# sourceMappingURL=types-ambient.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-ambient.d.ts","sourceRoot":"","sources":["types-ambient.js"],"names":[],"mappings":"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"}