@agoric/zoe 0.26.3-upgrade-18a-dev-4ee0508.0 → 0.26.3-upgrade-20-dev-086463b.0

package/src/zoeService/zoe.js

@@ -28,7 +28,11 @@ import { getZcfBundleCap } from './createZCFVat.js';
 import { defaultFeeIssuerConfig, prepareFeeMint } from './feeMint.js';
 import { ZoeServiceI } from '../typeGuards.js';
 
-/** @import {Baggage} from '@agoric/vat-data' */
+/**
+ * @import {VatAdminSvc} from '@agoric/swingset-vat';
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {FeeIssuerConfig, FeeMintAccess, ZCFSpec, ZoeService} from './types.js';
+ */
 
 /**
  * Create a durable instance of Zoe.
@@ -289,3 +293,6 @@ export { makeDurableZoeKit, makeZoeKit };
 /**
  * @typedef {ReturnType<typeof makeDurableZoeKit>} ZoeKit
  */
+
+// eslint-disable-next-line import/export -- no named value exports; only types
+export * from '../types-index.js';

package/src/zoeService/zoeSeat.d.ts

@@ -16,10 +16,7 @@ export function makeZoeSeatAdminFactory(baggage: import("@agoric/vat-data").Bagg
         fail(reason: any): void;
         /** @param {HandleOfferResult} result */
         resolveExitAndResult({ offerResultPromise, exitObj }: HandleOfferResult): void;
-        getExitSubscriber(): import("@endo/exo").Guarded<{
-            subscribeAfter(publishCount?: bigint): Promise<any>;
-            getUpdateSince(updateCount: any): any;
-        }>;
+        getExitSubscriber(): globalThis.Subscriber<any>;
         finalPayouts(payments: any): Promise<void>;
     }>;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"zoeSeat.d.ts","sourceRoot":"","sources":["zoeSeat.js"],"names":[],"mappings":"AAkDO,iDAFI,OAAO,kBAAkB,EAAE,OAAO,uBAwWhC,UAAU,YACV,cAAc,uBACd,mBAAmB,iBACnB,aAAa,YACb,IAAI,CAAC,OAAO,CAAC,2BACb,OAAO;;;;;;;;;;;;;;;;QA3IZ,wCAAwC;8DAA5B,iBAAiB;;;;;;;EAoKpC"}
+{"version":3,"file":"zoeSeat.d.ts","sourceRoot":"","sources":["zoeSeat.js"],"names":[],"mappings":"AAkDO,iDAFI,OAAO,kBAAkB,EAAE,OAAO,uBA0WhC,UAAU,YACV,cAAc,uBACd,mBAAmB,iBACnB,aAAa,YACb,IAAI,CAAC,OAAO,CAAC,2BACb,OAAO;;;;;;;;;;;;;;;;QA3IZ,wCAAwC;8DAA5B,iBAAiB;;;;EAoKpC"}

package/src/zoeService/zoeSeat.js

@@ -4,10 +4,10 @@ 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 { NonNullish } from '@agoric/internal';
 
 import { satisfiesWant } from '../contractFacet/offerSafety.js';
-import '../types-ambient.js';
-import '../internal-types.js';
+
 import {
   declareOldZoeSeatAdminKind,
   OriginalZoeSeatIKit,
@@ -143,8 +143,10 @@ export const makeZoeSeatAdminFactory = baggage => {
           // doExit(), which ensures that finalPayouts() has set state.payouts.
           return E.when(
             state.subscriber.subscribeAfter(),
-            () => state.payouts[keyword],
-            () => state.payouts[keyword],
+            () =>
+              NonNullish(state.payouts[keyword], `No payout for "${keyword}"`),
+            () =>
+              NonNullish(state.payouts[keyword], `No payout for "${keyword}"`),
           );
         },
 

package/src/zoeService/zoeStorageManager.d.ts

@@ -4,7 +4,7 @@ export function makeZoeStorageManager(createZCFVat: CreateZCFVat, getBundleCapFo
     getFeeBrand: () => Brand;
 }, zoeBaggage: Baggage): import("@endo/exo").GuardedKit<{
     zoeServiceDataAccess: {
-        getInvitationIssuer: () => globalThis.Issuer<"set", InvitationDetails>;
+        getInvitationIssuer: () => globalThis.Issuer<"set", import("@agoric/zoe").InvitationDetails>;
         getBundleIDFromInstallation(allegedInstallation: any): Promise<string | undefined>;
         getPublicFacet(instance: any): any;
         getBrands(instance: any): any;
@@ -13,14 +13,14 @@ export function makeZoeStorageManager(createZCFVat: CreateZCFVat, getBundleCapFo
         getTerms(instance: any): any;
         getInstallation(instance: any): any;
         getProposalShapeForInvitation: (invitationHandle: any) => any;
-        installBundle: (allegedBundle: any, bundleLabel: any) => Promise<Installation<any>>;
-        installBundleID(bundleID: any, bundleLabel: any): Promise<Installation<unknown>>;
+        installBundle: (allegedBundle: any, bundleLabel: any) => Promise<globalThis.Installation>;
+        installBundleID(bundleID: any, bundleLabel: any): Promise<globalThis.Installation<unknown>>;
     };
     makeOfferAccess: {
         getAssetKindByBrand: GetAssetKindByBrand;
         getInstanceAdmin(instance: any): any;
         getProposalShapeForInvitation: (invitationHandle: any) => any;
-        getInvitationIssuer: () => globalThis.Issuer<"set", InvitationDetails>;
+        getInvitationIssuer: () => globalThis.Issuer<"set", import("@agoric/zoe").InvitationDetails>;
         depositPayments(proposal: any, payments: any): Promise<Allocation>;
     };
     startInstanceAccess: {
@@ -33,7 +33,7 @@ export function makeZoeStorageManager(createZCFVat: CreateZCFVat, getBundleCapFo
         }>;
     };
     invitationIssuerAccess: {
-        getInvitationIssuer: () => globalThis.Issuer<"set", InvitationDetails>;
+        getInvitationIssuer: () => globalThis.Issuer<"set", import("@agoric/zoe").InvitationDetails>;
     };
 }>;
 import type { Baggage } from '@agoric/vat-data';

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,OAAO,sBAAsB,EAAE,mBAAmB,WAClD;IACL,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,WAAW,EAAE,MAAM,KAAK,CAAC;CAC3B,cACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;kBAZkC,CAAC;qBAC3B,CAAC;oBAA0B,CAAC;;;;;;;GAsbrD;6BAlc0B,kBAAkB"}
+{"version":3,"file":"zoeStorageManager.d.ts","sourceRoot":"","sources":["zoeStorageManager.js"],"names":[],"mappings":"AAyDO,oDAXI,YAAY,qBAEZ,iBAAiB,kBACjB,OAAO,sBAAsB,EAAE,mBAAmB,WAClD;IACL,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,WAAW,EAAE,MAAM,KAAK,CAAC;CAC3B,cACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;kBANgC,CAAC;qBAChD,CAAC;oBACa,CAAC;;;;;;;GA+ajB;6BApcyB,kBAAkB"}

package/src/zoeService/zoeStorageManager.js

@@ -21,15 +21,16 @@ import { prepareInvitationKit } from './makeInvitation.js';
 import { makeInstanceAdminStorage } from './instanceAdminStorage.js';
 import { makeInstallationStorage } from './installationStorage.js';
 
-/// <reference path="./types.js" />
-import './internal-types.js';
 import {
   InstanceStorageManagerIKit,
   ZoeMintI,
   ZoeStorageManagerIKit,
 } from '../typeGuards.js';
 
-/** @import {Baggage} from '@agoric/vat-data' */
+/**
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {InvitationAmount} from '@agoric/zoe';
+ */
 
 const { ownKeys } = Reflect;
 

package/tools/fakePriceAuthority.d.ts

@@ -6,7 +6,7 @@
  * @property {Array<[number, number]>} [tradeList]
  * @property {import('@agoric/time').TimerService} timer
  * @property {import('@agoric/time').RelativeTime} [quoteInterval]
- * @property {ERef<Mint<'set'>>} [quoteMint]
+ * @property {ERef<Mint<'set', PriceDescription>>} [quoteMint]
  * @property {Amount<'nat'>} [unitAmountIn]
  */
 /**
@@ -24,8 +24,9 @@ export type FakePriceAuthorityOptions = {
     tradeList?: [number, number][] | undefined;
     timer: import("@agoric/time").TimerService;
     quoteInterval?: import("@agoric/time").RelativeTime | undefined;
-    quoteMint?: globalThis.ERef<globalThis.Mint<"set">> | undefined;
+    quoteMint?: globalThis.ERef<globalThis.Mint<"set", PriceDescription>> | undefined;
     unitAmountIn?: import("@agoric/ertp").NatAmount | undefined;
 };
 import type { PriceAuthority } from '@agoric/zoe/tools/types.js';
+import type { PriceDescription } 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":"AAyBA;;;;;;;;;;GAUG;AAEH;;;;;;GAMG;AACH,gDAHW,yBAAyB,GACvB,OAAO,CAAC,cAAc,CAAC,CAwSnC;;mBAvTa,KAAK,CAAC,KAAK,CAAC;oBACZ,KAAK,CAAC,KAAK,CAAC;;;WAGZ,OAAO,cAAc,EAAE,YAAY;;;;;oCAhB4C,4BAA4B"}
+{"version":3,"file":"fakePriceAuthority.d.ts","sourceRoot":"","sources":["fakePriceAuthority.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;GAUG;AAEH;;;;;;GAMG;AACH,gDAHW,yBAAyB,GACvB,OAAO,CAAC,cAAc,CAAC,CAwSnC;;mBAvTa,KAAK,CAAC,KAAK,CAAC;oBACZ,KAAK,CAAC,KAAK,CAAC;;;WAGZ,OAAO,cAAc,EAAE,YAAY;;;;;oCAhB4C,4BAA4B;sCAA5B,4BAA4B"}

package/tools/fakePriceAuthority.js

@@ -1,16 +1,19 @@
 import { Fail } from '@endo/errors';
-import { makePromiseKit } from '@endo/promise-kit';
 import { E } from '@endo/eventual-send';
 import { Far } from '@endo/marshal';
+import { makePromiseKit } from '@endo/promise-kit';
 
-import { makeIssuerKit, AssetKind, AmountMath } from '@agoric/ertp';
+import { AmountMath } from '@agoric/ertp';
 import {
-  makeNotifierKit,
   makeNotifierFromAsyncIterable,
+  makeNotifierKit,
 } from '@agoric/notifier';
 import { TimeMath } from '@agoric/time';
 
-import { natSafeMath } from '../src/contractSupport/index.js';
+import {
+  makePriceQuoteIssuer,
+  natSafeMath,
+} from '../src/contractSupport/index.js';
 
 /**
  * @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js';
@@ -31,7 +34,7 @@ const timestampLTE = (a, b) => TimeMath.compareAbs(a, b) <= 0;
  * @property {Array<[number, number]>} [tradeList]
  * @property {import('@agoric/time').TimerService} timer
  * @property {import('@agoric/time').RelativeTime} [quoteInterval]
- * @property {ERef<Mint<'set'>>} [quoteMint]
+ * @property {ERef<Mint<'set', PriceDescription>>} [quoteMint]
  * @property {Amount<'nat'>} [unitAmountIn]
  */
 
@@ -51,7 +54,7 @@ export async function makeFakePriceAuthority(options) {
     timer,
     unitAmountIn = AmountMath.make(actualBrandIn, 1n),
     quoteInterval = 1n,
-    quoteMint = makeIssuerKit('quote', AssetKind.SET).mint,
+    quoteMint = makePriceQuoteIssuer().mint,
   } = options;
 
   tradeList ||

package/tools/fakeVatAdmin.d.ts

@@ -1,7 +1,5 @@
 export const zcfBundleCap: any;
 export default fakeVatAdmin;
-export type BundleID = import("@agoric/swingset-vat").BundleID;
-export type EndoZipBase64Bundle = import("@agoric/swingset-vat").EndoZipBase64Bundle;
 export type BundleCap = import("@agoric/swingset-vat").BundleCap;
 declare const fakeVatAdmin: {
     getBundleCap: (bundleID: any) => Promise<any>;
@@ -90,14 +88,22 @@ export function makeFakeVatAdmin(testContextSetter?: (...args: any) => unknown,
         getExitMessage: () => any;
         getHasExited: () => boolean;
         getExitWithFailure: () => any;
-        installBundle: (id: any, bundle: any) => any;
+        /**
+         * @param {string} id
+         * @param {EndoZipBase64Bundle | TestBundle} bundle
+         */
+        installBundle: (id: string, bundle: EndoZipBase64Bundle | TestBundle) => any;
         installNamedBundle: (name: any, id: any, bundle: any) => any;
         getCriticalVatKey: () => {};
         getVatPowers: () => {
             D: (bcap: any) => {
-                getBundle: () => globalThis.EndoZipBase64Bundle;
+                getBundle: () => EndoZipBase64Bundle | {
+                    moduleFormat: "test";
+                } | undefined;
             };
         };
     };
 };
+import type { EndoZipBase64Bundle } from '@agoric/swingset-vat';
+import type { TestBundle } from '@agoric/swingset-vat';
 //# sourceMappingURL=fakeVatAdmin.d.ts.map

package/tools/fakeVatAdmin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fakeVatAdmin.d.ts","sourceRoot":"","sources":["fakeVatAdmin.js"],"names":[],"mappings":"AAsBA,+BAA4C;;uBAR7B,OAAO,sBAAsB,EAAE,QAAQ;kCACvC,OAAO,sBAAsB,EAAE,mBAAmB;wBAGlD,OAAO,sBAAsB,EAAE,SAAS;AAoJvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA8C;AA9I9C;;;GAGG;AACH,qDAHW,CAAC,GAAG,IAAI,KAAA,KAAK,OAAO,eACpB,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqIjC"}
+{"version":3,"file":"fakeVatAdmin.d.ts","sourceRoot":"","sources":["fakeVatAdmin.js"],"names":[],"mappings":"AAyBA,+BAA4C;;wBAJ7B,OAAO,sBAAsB,EAAE,SAAS;AA4JvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA8C;AAtJ9C;;;GAGG;AACH,qDAHW,CAAC,GAAG,IAAI,KAAA,KAAK,OAAO,eACpB,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAgH9B;;;WAGG;4BAFQ,MAAM,UACN,mBAAmB,GAAG,UAAU;;;;;;kCAxGkB,MAAM;;;;;EAmItE;yCAzJ2D,sBAAsB;gCAAtB,sBAAsB"}

package/tools/fakeVatAdmin.js

@@ -1,4 +1,5 @@
-// @jessie-check
+// no jessie-check because this code runs only in Node for testing
+/* eslint-env node */
 
 import { Fail } from '@endo/errors';
 import { E } from '@endo/eventual-send';
@@ -12,8 +13,10 @@ import { handlePKitWarning } from '../src/handleWarning.js';
 import { makeHandle } from '../src/makeHandle.js';
 import zcfBundle from '../bundles/bundle-contractFacet.js';
 
-/** @typedef { import('@agoric/swingset-vat').BundleID} BundleID */
-/** @typedef { import('@agoric/swingset-vat').EndoZipBase64Bundle} EndoZipBase64Bundle */
+/**
+ * @import {MapStore} from '@agoric/swingset-liveslots';
+ * @import {BundleID, EndoZipBase64Bundle, TestBundle} from '@agoric/swingset-vat';
+ */
 
 // this simulates a bundlecap, which is normally a swingset "device node"
 /** @typedef { import('@agoric/swingset-vat').BundleCap } BundleCap */
@@ -34,8 +37,8 @@ function makeFakeVatAdmin(testContextSetter = undefined, makeRemote = x => x) {
   let exitWithFailure;
   /** @type {MapStore<BundleID, BundleCap>} */
   const idToBundleCap = makeScalarMapStore('idToBundleCap');
-  /** @type {MapStore<BundleCap, EndoZipBase64Bundle>} */
-  const bundleCapToBundle = makeScalarMapStore('bundleCapToBundle');
+  /** @type {Map<BundleCap, EndoZipBase64Bundle | {moduleFormat: 'test'}>} */
+  const bundleCapToBundle = new Map();
   /** @type {MapStore<string, BundleID>} */
   const nameToBundleID = makeScalarMapStore('nameToBundleID');
   const fakeVatPowers = {
@@ -136,17 +139,25 @@ function makeFakeVatAdmin(testContextSetter = undefined, makeRemote = x => x) {
     getExitMessage: () => exitMessage,
     getHasExited: () => hasExited,
     getExitWithFailure: () => exitWithFailure,
+    /**
+     * @param {string} id
+     * @param {EndoZipBase64Bundle | TestBundle} bundle
+     */
     installBundle: (id, bundle) => {
       if (idToBundleCap.has(id)) {
-        assert.equal(
-          bundle.endoZipBase64,
-          bundleCapToBundle.get(idToBundleCap.get(id)).endoZipBase64,
-        );
+        const extant = bundleCapToBundle.get(idToBundleCap.get(id));
+        assert(extant);
+        assert.equal(bundle.moduleFormat, extant.moduleFormat);
+        if (extant.moduleFormat === 'endoZipBase64') {
+          // Narrow bundle.moduleFormat now that extant.moduleFormat is narrowed
+          assert.equal(bundle.moduleFormat, extant.moduleFormat);
+          assert.equal(bundle.endoZipBase64, extant.endoZipBase64);
+        }
         return idToBundleCap.get(id);
       }
       const bundleCap = fakeBundleCap();
       idToBundleCap.init(id, bundleCap);
-      bundleCapToBundle.init(bundleCap, bundle);
+      bundleCapToBundle.set(bundleCap, bundle);
       return bundleCap;
     },
     installNamedBundle: (name, id, bundle) => {

package/tools/manualPriceAuthority.d.ts

@@ -1,4 +1,5 @@
 /**
+ * @import {Amount, Brand, Issuer, IssuerKit, Payment, Purse} from '@agoric/ertp';
  * @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js';
  */
 /**
@@ -7,7 +8,7 @@
  * @param {Brand<'nat'>} options.actualBrandOut
  * @param {Ratio} options.initialPrice
  * @param {import('@agoric/time').TimerService} options.timer
- * @param {IssuerKit<'set'>} [options.quoteIssuerKit]
+ * @param {IssuerKit<'set', PriceDescription>} [options.quoteIssuerKit]
  * @returns {PriceAuthority & { setPrice: (Ratio) => void; disable: () => void }}
  */
 export function makeManualPriceAuthority(options: {
@@ -15,11 +16,14 @@ export function makeManualPriceAuthority(options: {
     actualBrandOut: Brand<"nat">;
     initialPrice: Ratio;
     timer: import("@agoric/time").TimerService;
-    quoteIssuerKit?: globalThis.IssuerKit<"set"> | undefined;
+    quoteIssuerKit?: IssuerKit<"set", PriceDescription> | undefined;
 }): PriceAuthority & {
     setPrice: (Ratio: any) => void;
     disable: () => void;
 };
 export type ManualPriceAuthority = ReturnType<typeof makeManualPriceAuthority>;
+import type { Brand } from '@agoric/ertp';
+import type { PriceDescription } from '@agoric/zoe/tools/types.js';
+import type { IssuerKit } from '@agoric/ertp';
 import type { PriceAuthority } from '@agoric/zoe/tools/types.js';
 //# sourceMappingURL=manualPriceAuthority.d.ts.map

package/tools/manualPriceAuthority.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manualPriceAuthority.d.ts","sourceRoot":"","sources":["manualPriceAuthority.js"],"names":[],"mappings":"AAYA;;GAEG;AAEH;;;;;;;;GAQG;AACH,kDAPG;IAA8B,aAAa,EAAnC,KAAK,CAAC,KAAK,CAAC;IACU,cAAc,EAApC,KAAK,CAAC,KAAK,CAAC;IACG,YAAY,EAA3B,KAAK;IACwC,KAAK,EAAlD,OAAO,cAAc,EAAE,YAAY;IACR,cAAc;CACjD,GAAU,cAAc,GAAG;IAAE,QAAQ,EAAE,CAAC,KAAK,KAAA,KAAK,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,CA8E/E;mCACa,UAAU,CAAC,OAAO,wBAAwB,CAAC;oCAzFoC,4BAA4B"}
+{"version":3,"file":"manualPriceAuthority.d.ts","sourceRoot":"","sources":["manualPriceAuthority.js"],"names":[],"mappings":"AAaA;;;GAGG;AAEH;;;;;;;;GAQG;AACH,kDAPG;IAA8B,aAAa,EAAnC,MAAM,KAAK,CAAC;IACU,cAAc,EAApC,MAAM,KAAK,CAAC;IACG,YAAY,EAA3B,KAAK;IACwC,KAAK,EAAlD,OAAO,cAAc,EAAE,YAAY;IACU,cAAc;CACnE,GAAU,cAAc,GAAG;IAAE,QAAQ,EAAE,CAAC,KAAK,KAAA,KAAK,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,CA8E/E;mCACa,UAAU,CAAC,OAAO,wBAAwB,CAAC;2BA1FU,cAAc;sCACY,4BAA4B;+BADtD,cAAc;oCACY,4BAA4B"}

package/tools/manualPriceAuthority.js

@@ -1,16 +1,18 @@
 // @jessie-check
 
-import { AmountMath, makeIssuerKit, AssetKind } from '@agoric/ertp';
+import { AmountMath } from '@agoric/ertp';
+import { makeNotifierKit } from '@agoric/notifier';
 import { E } from '@endo/eventual-send';
 import { Far } from '@endo/marshal';
-import { makeNotifierKit } from '@agoric/notifier';
 import {
-  makeOnewayPriceAuthorityKit,
-  floorMultiplyBy,
   floorDivideBy,
+  floorMultiplyBy,
+  makeOnewayPriceAuthorityKit,
+  makePriceQuoteIssuer,
 } from '../src/contractSupport/index.js';
 
 /**
+ * @import {Amount, Brand, Issuer, IssuerKit, Payment, Purse} from '@agoric/ertp';
  * @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js';
  */
 
@@ -20,7 +22,7 @@ import {
  * @param {Brand<'nat'>} options.actualBrandOut
  * @param {Ratio} options.initialPrice
  * @param {import('@agoric/time').TimerService} options.timer
- * @param {IssuerKit<'set'>} [options.quoteIssuerKit]
+ * @param {IssuerKit<'set', PriceDescription>} [options.quoteIssuerKit]
  * @returns {PriceAuthority & { setPrice: (Ratio) => void; disable: () => void }}
  */
 export function makeManualPriceAuthority(options) {
@@ -29,7 +31,7 @@ export function makeManualPriceAuthority(options) {
     actualBrandOut,
     initialPrice, // brandOut / brandIn
     timer,
-    quoteIssuerKit = makeIssuerKit('quote', AssetKind.SET),
+    quoteIssuerKit = makePriceQuoteIssuer(),
   } = options;
   const { brand, issuer: quoteIssuer, mint: quoteMint } = quoteIssuerKit;
 

package/tools/scriptedOracle.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @import {ZoeService} from '../src/types-index.js';
+ */
 /**
  * Start an instance of an Oracle that follows a script. The Oracle has access
  * to a timer, and looks in the script for events indexed by the current time.
@@ -15,13 +18,14 @@
  * @param {Issuer} feeIssuer
  */
 export function makeScriptedOracle(script: Record<string, any>, oracleInstallation: Installation<import("../src/contracts/oracle.js").OracleStart>, timer: import("@agoric/time").TimerService, zoe: ZoeService, feeIssuer: Issuer): Promise<{
-    publicFacet: {
+    publicFacet: object & {
         query(query: OracleQuery): Promise<unknown>;
-        makeQueryInvitation(query: OracleQuery): Promise<Invitation<unknown, never>>;
+        makeQueryInvitation(query: OracleQuery): Promise<globalThis.Invitation<unknown, never>>;
     } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
         query(query: OracleQuery): Promise<unknown>;
-        makeQueryInvitation(query: OracleQuery): Promise<Invitation<unknown, never>>;
+        makeQueryInvitation(query: OracleQuery): Promise<globalThis.Invitation<unknown, never>>;
     }>;
     creatorFacet: OracleCreatorFacet;
 }>;
+import type { ZoeService } from '../src/types-index.js';
 //# sourceMappingURL=scriptedOracle.d.ts.map

package/tools/scriptedOracle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scriptedOracle.d.ts","sourceRoot":"","sources":["scriptedOracle.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,2CANW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,sBACnB,YAAY,CAAC,OAAO,4BAA4B,EAAE,WAAW,CAAC,SAC9D,OAAO,cAAc,EAAE,YAAY,OACnC,UAAU,aACV,MAAM;;;;;;;;;GAqChB"}
+{"version":3,"file":"scriptedOracle.d.ts","sourceRoot":"","sources":["scriptedOracle.js"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,2CANW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,sBACnB,YAAY,CAAC,OAAO,4BAA4B,EAAE,WAAW,CAAC,SAC9D,OAAO,cAAc,EAAE,YAAY,OACnC,UAAU,aACV,MAAM;;;;;;;;;GAqChB;gCAtD4B,uBAAuB"}

package/tools/scriptedOracle.js

@@ -2,6 +2,10 @@ import { TimeMath } from '@agoric/time';
 import { E } from '@endo/eventual-send';
 import { Far } from '@endo/marshal';
 
+/**
+ * @import {ZoeService} from '../src/types-index.js';
+ */
+
 /**
  * Start an instance of an Oracle that follows a script. The Oracle has access
  * to a timer, and looks in the script for events indexed by the current time.

package/tools/scriptedPriceAuthority.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scriptedPriceAuthority.d.ts","sourceRoot":"","sources":["scriptedPriceAuthority.js"],"names":[],"mappings":"AAUA;;GAEG;AAEH,yEAoFC;oCAvF4F,4BAA4B"}
+{"version":3,"file":"scriptedPriceAuthority.d.ts","sourceRoot":"","sources":["scriptedPriceAuthority.js"],"names":[],"mappings":"AAWA;;GAEG;AAEH,yEAoFC;oCAvF4F,4BAA4B"}

package/tools/scriptedPriceAuthority.js

@@ -1,11 +1,12 @@
-import { AmountMath, makeIssuerKit, AssetKind } from '@agoric/ertp';
-import { E } from '@endo/eventual-send';
-import { Far } from '@endo/marshal';
+import { AmountMath } from '@agoric/ertp';
 import { observeNotifier } from '@agoric/notifier';
 import { TimeMath } from '@agoric/time';
+import { E } from '@endo/eventual-send';
+import { Far } from '@endo/marshal';
 import {
-  natSafeMath,
   makeOnewayPriceAuthorityKit,
+  makePriceQuoteIssuer,
+  natSafeMath,
 } from '../src/contractSupport/index.js';
 
 /**
@@ -20,7 +21,7 @@ export function makeScriptedPriceAuthority(options) {
     timer,
     unitAmountIn = AmountMath.make(actualBrandIn, 1n),
     quoteInterval = 1n,
-    quoteIssuerKit = makeIssuerKit('quote', AssetKind.SET),
+    quoteIssuerKit = makePriceQuoteIssuer(),
   } = options;
   const { brand, issuer: quoteIssuer, mint: quoteMint } = quoteIssuerKit;
   let currentPrice = priceList[0];

package/tools/setup-zoe.d.ts

@@ -1,34 +1,40 @@
 export function makeZoeKitForTest(vatAdminSvc?: VatAdminSvc): {
-    zoeService: import("@endo/exo").Guarded<ZoeService>;
+    zoeService: import("@endo/exo").Guarded<globalThis.ZoeService>;
     zoeConfigFacet: import("@endo/exo").Guarded<{
         updateZcfBundleId(bundleId: any): void;
     }>;
     feeMintAccess: FeeMintAccess;
     setVatAdminService: ((lateVatAdminSvc: any) => void) & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, (lateVatAdminSvc: any) => void>;
 };
-export function makeZoeForTest(vatAdminSvc?: VatAdminSvc): import("@endo/exo").Guarded<ZoeService>;
+export function makeZoeForTest(vatAdminSvc?: VatAdminSvc): import("@endo/exo").Guarded<globalThis.ZoeService>;
 export function setUpZoeForTest<T extends unknown = any>({ setJig, feeIssuerConfig, vatAdminSvc, useNearRemote, }?: {
     setJig?: ((jig: T) => void) | undefined;
     feeIssuerConfig?: FeeIssuerConfig | undefined;
     vatAdminSvc?: VatAdminSvc | undefined;
     useNearRemote?: boolean | undefined;
 }): Promise<{
-    zoe: import("@endo/exo").Guarded<ZoeService>;
+    zoe: import("@endo/exo").Guarded<globalThis.ZoeService>;
     feeMintAccessP: FeeMintAccess;
-    bundleAndInstall: (path: string) => Promise<Installation>;
+    bundleAndInstall: (pathOrExports: object) => Promise<Installation>;
     vatAdminSvc: VatAdminSvc;
     vatAdminState: {
         getExitMessage: () => any;
         getHasExited: () => boolean;
         getExitWithFailure: () => any;
-        installBundle: (id: any, bundle: any) => any;
+        installBundle: (id: string, bundle: EndoZipBase64Bundle | TestBundle) => any;
         installNamedBundle: (name: any, id: any, bundle: any) => any;
         getCriticalVatKey: () => {};
         getVatPowers: () => {
             D: (bcap: any) => {
-                getBundle: () => EndoZipBase64Bundle;
+                getBundle: () => EndoZipBase64Bundle | {
+                    moduleFormat: "test";
+                } | undefined;
             };
         };
     } | undefined;
 }>;
+import type { FeeIssuerConfig } from '../src/types-index.js';
+import type { Installation } from '../src/types-index.js';
+import type { EndoZipBase64Bundle } from '@agoric/swingset-vat';
+import type { TestBundle } from '@agoric/swingset-vat';
 //# sourceMappingURL=setup-zoe.d.ts.map

package/tools/setup-zoe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup-zoe.d.ts","sourceRoot":"","sources":["setup-zoe.js"],"names":[],"mappings":"AAUO,gDAFI,WAAW;;;;;;;EAOrB;AAKM,6CAFI,WAAW,2CAGqB;AAapC,gCAPgB,CAAC,mFAErB;IAAmC,MAAM,UAA3B,CAAC,KAAK,IAAI;IACU,eAAe;IACnB,WAAW;IACf,aAAa;CAAC;;;6BA2B9B,MAAM,KACJ,OAAO,CAAC,YAAY,CAAC;;;;;;;;;;;;;;;GAiBnC"}
+{"version":3,"file":"setup-zoe.d.ts","sourceRoot":"","sources":["setup-zoe.js"],"names":[],"mappings":"AAgBO,gDAFI,WAAW;;;;;;;EAOrB;AAKM,6CAFI,WAAW,sDAGqB;AAapC,gCAPgB,CAAC,mFAErB;IAAmC,MAAM,UAA3B,CAAC,KAAK,IAAI;IACU,eAAe;IACnB,WAAW;IACf,aAAa;CAAC;;;sCAmD9B,MAAM,KACJ,OAAO,CAAC,YAAY,CAAC;;;;;;;;;;;;;;;;;GAoBnC;qCApG+C,uBAAuB;kCAAvB,uBAAuB;yCADrB,sBAAsB;gCAAtB,sBAAsB"}

package/tools/setup-zoe.js

@@ -2,9 +2,15 @@ import { E, makeLoopback } from '@endo/captp';
 
 import { makeScalarBigMapStore } from '@agoric/vat-data';
 import bundleSource from '@endo/bundle-source';
+import { bundleTestExports } from '@endo/import-bundle';
 import { makeDurableZoeKit } from '../src/zoeService/zoe.js';
 import fakeVatAdmin, { makeFakeVatAdmin } from './fakeVatAdmin.js';
 
+/**
+ * @import {EndoZipBase64Bundle, TestBundle} from '@agoric/swingset-vat';
+ * @import {FeeIssuerConfig, Installation} from '../src/types-index.js';
+ */
+
 /**
  * @param {VatAdminSvc} [vatAdminSvc]
  */
@@ -57,13 +63,40 @@ export const setUpZoeForTest = async ({
   );
 
   /**
-   * @param {string} path
+   * @param {object} pathOrExports
+   * @returns {Promise<EndoZipBase64Bundle | TestBundle>}
+   */
+  const bundleModule = async pathOrExports => {
+    if (typeof pathOrExports === 'string') {
+      const path = pathOrExports;
+      return bundleSource(path);
+    } else {
+      assert.equal(
+        Object.getOwnPropertyDescriptor(pathOrExports, Symbol.toStringTag)
+          ?.value,
+        'Module',
+      );
+      // Copy all the properties so this object can be hardened.
+      const exports = { ...pathOrExports };
+      return bundleTestExports(exports);
+    }
+  };
+
+  /**
+   * Bundle the source module (either as file system path or a Module object)
+   * and return an Installation. The bundleID is random and should not be relied
+   * upon in tests of this variety.
+   *
+   * @param {object} pathOrExports
    * @returns {Promise<Installation>}
    */
-  const bundleAndInstall = async path => {
-    const bundle = await bundleSource(path);
-    const id = `b1-${path}`;
-    assert(vatAdminState, 'installBundle called before vatAdminState defined');
+  const bundleAndInstall = async pathOrExports => {
+    const bundle = await bundleModule(pathOrExports);
+    assert(
+      vatAdminState,
+      'bundleAndInstall called before vatAdminState defined',
+    );
+    const id = `b1-zoe-test-${Math.random()}`;
     vatAdminState.installBundle(id, bundle);
     return E(zoeService).installBundleID(id);
   };

package/tools/test-utils.d.ts

@@ -1,4 +1,4 @@
-export function withAmountUtils(kit: Pick<IssuerKit<"nat">, "brand" | "issuer" | "mint">): {
+export function withAmountUtils(kit: Pick<IssuerKit<"nat", any>, "brand" | "issuer" | "mint">): {
     /** @param {NatValue} v */
     make: (v: NatValue) => import("@agoric/ertp").NatAmount;
     makeEmpty: () => import("@agoric/ertp").NatAmount;
@@ -6,15 +6,19 @@ export function withAmountUtils(kit: Pick<IssuerKit<"nat">, "brand" | "issuer" |
      * @param {NatValue} n
      * @param {NatValue} [d]
      */
-    makeRatio: (n: NatValue, d?: NatValue) => Ratio;
+    makeRatio: (n: NatValue, d?: NatValue) => import("@agoric/ertp/src/ratio.js").Ratio;
     /** @param {number} n */
     units: (n: number) => import("@agoric/ertp").NatAmount;
     /** The intact Exo remotable */
-    issuerKit: Pick<globalThis.IssuerKit<"nat">, "brand" | "issuer" | "mint">;
-    brand: globalThis.Brand<"nat">;
-    issuer: globalThis.Issuer<"nat", import("@endo/patterns").Key>;
-    mint: globalThis.Mint<"nat", import("@endo/patterns").Key>;
+    issuerKit: Pick<IssuerKit<"nat", any>, "brand" | "issuer" | "mint">;
+    brand: Brand<"nat">;
+    issuer: Issuer<"nat", any>;
+    mint: globalThis.Mint<"nat", any>;
 };
 export { makeFakeStorageKit } from "@agoric/internal/src/storage-test-utils.js";
 export type AmountUtils = ReturnType<typeof withAmountUtils>;
+import type { IssuerKit } from '@agoric/ertp';
+import type { NatValue } from '@agoric/ertp';
+import type { Brand } from '@agoric/ertp';
+import type { Issuer } from '@agoric/ertp';
 //# sourceMappingURL=test-utils.d.ts.map

package/tools/test-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["test-utils.js"],"names":[],"mappings":"AAIO,qCADK,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;IAK3D,0BAA0B;cAAd,QAAQ;;IAGpB;;;OAGG;mBAFQ,QAAQ,MACR,QAAQ;IAGnB,wBAAwB;eAAZ,MAAM;IAGlB,+BAA+B;;;;;EAGlC;;0BACa,UAAU,CAAC,OAAO,eAAe,CAAC"}
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["test-utils.js"],"names":[],"mappings":"AAQO,qCADK,IAAI,CAAC,UAAU,KAAK,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;IAKhE,0BAA0B;cAAd,QAAQ;;IAGpB;;;OAGG;mBAFQ,QAAQ,MACR,QAAQ;IAGnB,wBAAwB;eAAZ,MAAM;IAGlB,+BAA+B;;;;;EAGlC;;0BACa,UAAU,CAAC,OAAO,eAAe,CAAC;+BAvB2B,cAAc;8BAAd,cAAc;2BAAd,cAAc;4BAAd,cAAc"}

package/tools/test-utils.js

@@ -1,7 +1,11 @@
 import { AmountMath } from '@agoric/ertp';
-import { makeRatio } from '../src/contractSupport/ratio.js';
+import { makeRatio } from '../src/contractSupport/index.js';
 
-/** @param {Pick<IssuerKit<'nat'>, 'brand' | 'issuer' | 'mint'>} kit */
+/**
+ * @import {Amount, Brand, DepositFacet, Issuer, IssuerKit, NatValue} from '@agoric/ertp';
+ */
+
+/** @param {Pick<IssuerKit<'nat', any>, 'brand' | 'issuer' | 'mint'>} kit */
 export const withAmountUtils = kit => {
   const decimalPlaces = kit.issuer.getDisplayInfo?.()?.decimalPlaces ?? 6;
   return {

package/tools/types.d.ts

@@ -139,4 +139,9 @@ export type PriceLevel = {
      */
     amountOut: Amount<"nat">;
 };
+import type { Amount } from '@agoric/ertp';
+import type { Payment } from '@agoric/ertp';
+import type { Brand } from '@agoric/ertp';
+import type { Issuer } from '@agoric/ertp';
+import type { Notifier } from '@agoric/notifier';
 //# sourceMappingURL=types.d.ts.map