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

package/src/issuerStorage.js

@@ -1,7 +1,7 @@
+import { deeplyFulfilledObject, objectMap } from '@agoric/internal';
 import { provideDurableWeakMapStore } from '@agoric/vat-data';
 import { E } from '@endo/eventual-send';
 
-import { arrayToObj } from './objArrayConversion.js';
 import { cleanKeywords } from './cleanProposal.js';
 import { makeIssuerRecord } from './issuerRecord.js';
 
@@ -124,11 +124,6 @@ export const provideIssuerStorage = zcfBaggage => {
     return getByBrand(brand);
   };
 
-  const storeIssuers = issuers => {
-    assertInstantiated();
-    return Promise.all(issuers.map(storeIssuer));
-  };
-
   /** @type {GetAssetKindByBrand} */
   const getAssetKindByBrand = brand => {
     assertInstantiated();
@@ -143,28 +138,14 @@ export const provideIssuerStorage = zcfBaggage => {
    */
   const storeIssuerKeywordRecord = async uncleanIssuerKeywordRecord => {
     assertInstantiated();
-    const keywords = cleanKeywords(uncleanIssuerKeywordRecord);
-    const issuerPs = keywords.map(
-      keyword => uncleanIssuerKeywordRecord[keyword],
-    );
-    // The issuers may not have been seen before, so we must wait for the
-    // issuer records to be available synchronously
-    const issuerRecords = await storeIssuers(issuerPs);
-    // AWAIT ///
-
-    const issuers = arrayToObj(
-      issuerRecords.map(record => record.issuer),
-      keywords,
+    cleanKeywords(uncleanIssuerKeywordRecord);
+    const issuerRecordPs = objectMap(uncleanIssuerKeywordRecord, issuerP =>
+      storeIssuer(issuerP),
     );
-    const brands = arrayToObj(
-      issuerRecords.map(record => record.brand),
-      keywords,
-    );
-
-    return harden({
-      issuers,
-      brands,
-    });
+    const issuerRecords = await deeplyFulfilledObject(issuerRecordPs);
+    const issuers = objectMap(issuerRecords, ({ issuer }) => issuer);
+    const brands = objectMap(issuerRecords, ({ brand }) => brand);
+    return harden({ issuers, brands });
   };
 
   /**
@@ -189,7 +170,10 @@ export const provideIssuerStorage = zcfBaggage => {
     return brandToIssuerRecord.get(brand).issuer;
   };
 
-  /** @type {IssuerStorageGetIssuerRecords} */
+  /**
+   * @param {Issuer[]} issuers
+   * @returns {IssuerRecords}
+   */
   const getIssuerRecords = issuers => {
     assertInstantiated();
     return issuers.map(issuerToIssuerRecord.get);

package/src/makeHandle.d.ts

@@ -1,4 +1,4 @@
-export function defineDurableHandle<H extends string>(baggage: MapStore<string, unknown>, handleType: H): H extends "Instance" ? () => Instance : () => Handle<H>;
+export function defineDurableHandle<H extends string>(baggage: Baggage, handleType: H): H extends "Instance" ? () => Instance : () => Handle<H>;
 export function makeHandle<H extends string>(handleType: H): H extends "Instance" ? Instance : Handle<H>;
-export type Baggage = import('@agoric/vat-data').Baggage;
+import type { Baggage } from '@agoric/vat-data';
 //# sourceMappingURL=makeHandle.d.ts.map

package/src/makeHandle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"makeHandle.d.ts","sourceRoot":"","sources":["makeHandle.js"],"names":[],"mappings":"AAkBO,uIAFmC,QAAQ,mBAajD;AAUM,yGAKN;sBAlCa,OAAO,kBAAkB,EAAE,OAAO"}
+{"version":3,"file":"makeHandle.d.ts","sourceRoot":"","sources":["makeHandle.js"],"names":[],"mappings":"AAkBO,oCAF2D,CAAC,+CAAD,CAAC,AADvD,GACsD,CAAC,AAArD,SAAS,UAAU,GAAG,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,CAAC,CAAC,CAanE;AAUM,2BAF+C,CAAC,6BAAD,CAAC,AAD3C,GAC0C,CAAC,AAAzC,SAAS,UAAU,GAAG,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,CAOvD;6BAlC0B,kBAAkB"}

package/src/makeHandle.js

@@ -8,7 +8,7 @@ import { HandleI } from './typeGuards.js';
 
 const { Fail } = assert;
 
-/** @typedef {import('@agoric/vat-data').Baggage} Baggage */
+/** @import {Baggage} from '@agoric/vat-data' */
 
 /**
  * @template {string} H

package/src/typeGuards.d.ts

@@ -18,53 +18,152 @@ export namespace TermsShape {
 export namespace InstanceRecordShape {
     export { InstallationShape as installation };
     export { InstanceHandleShape as instance };
-    export const terms: import("@endo/patterns").Matcher;
+    export let terms: import("@endo/patterns").Matcher;
 }
-export const HandleI: import("@endo/patterns").InterfaceGuard;
+export const HandleI: import("@endo/patterns").InterfaceGuard<{}>;
 export function makeHandleShape(name: any): import("@endo/patterns").Matcher;
 export const TimerShape: import("@endo/patterns").Matcher;
 export namespace FullProposalShape {
     export { AmountPatternKeywordRecordShape as want };
     export { AmountKeywordRecordShape as give };
-    export const exit: import("@endo/patterns").Matcher;
+    export let exit: import("@endo/patterns").Matcher;
 }
 /** @see {Proposal} type */
 export const ProposalShape: import("@endo/patterns").Matcher;
+export const EmptyProposalShape: import("@endo/patterns").Matcher;
 export function isOnDemandExitRule(exit: any): boolean;
 export function isWaivedExitRule(exit: ExitRule): exit is WaivedExitRule;
 export function isAfterDeadlineExitRule(exit: ExitRule): exit is AfterDeadlineExitRule;
 export const InvitationElementShape: import("@endo/patterns").Matcher;
-export const OfferHandlerI: import("@endo/patterns").InterfaceGuard;
+export const OfferHandlerI: import("@endo/patterns").InterfaceGuard<{
+    handle: import("@endo/patterns").MethodGuard;
+}>;
 export const SeatHandleAllocationsShape: import("@endo/patterns").Matcher;
 export const ZoeMintShape: import("@endo/patterns").Matcher;
-export const ZoeMintI: import("@endo/patterns").InterfaceGuard;
-export const ZcfMintI: import("@endo/patterns").InterfaceGuard;
+export const ZoeMintI: import("@endo/patterns").InterfaceGuard<{
+    getIssuerRecord: import("@endo/patterns").MethodGuard;
+    mintAndEscrow: import("@endo/patterns").MethodGuard;
+    withdrawAndBurn: import("@endo/patterns").MethodGuard;
+}>;
+export const ZcfMintI: import("@endo/patterns").InterfaceGuard<{
+    getIssuerRecord: import("@endo/patterns").MethodGuard;
+    mintGains: import("@endo/patterns").MethodGuard;
+    burnLosses: import("@endo/patterns").MethodGuard;
+}>;
 export const FeeMintAccessShape: import("@endo/patterns").Matcher;
-export const ExitObjectI: import("@endo/patterns").InterfaceGuard;
+export const ExitObjectI: import("@endo/patterns").InterfaceGuard<{
+    exit: import("@endo/patterns").MethodGuard;
+}>;
 export const ExitObjectShape: import("@endo/patterns").Matcher;
 export const InstanceAdminShape: import("@endo/patterns").Matcher;
-export const InstanceAdminI: import("@endo/patterns").InterfaceGuard;
+export const InstanceAdminI: import("@endo/patterns").InterfaceGuard<{
+    makeInvitation: import("@endo/patterns").MethodGuard;
+    saveIssuer: import("@endo/patterns").MethodGuard;
+    makeNoEscrowSeat: import("@endo/patterns").MethodGuard;
+    exitAllSeats: import("@endo/patterns").MethodGuard;
+    failAllSeats: import("@endo/patterns").MethodGuard;
+    exitSeat: import("@endo/patterns").MethodGuard;
+    failSeat: import("@endo/patterns").MethodGuard;
+    makeZoeMint: import("@endo/patterns").MethodGuard;
+    registerFeeMint: import("@endo/patterns").MethodGuard;
+    replaceAllocations: import("@endo/patterns").MethodGuard;
+    stopAcceptingOffers: import("@endo/patterns").MethodGuard;
+    setOfferFilter: import("@endo/patterns").MethodGuard;
+    getOfferFilter: import("@endo/patterns").MethodGuard;
+    getExitSubscriber: import("@endo/patterns").MethodGuard;
+    isBlocked: import("@endo/patterns").MethodGuard;
+    repairContractCompletionWatcher: import("@endo/patterns").MethodGuard;
+}>;
 export namespace InstanceStorageManagerIKit {
-    const instanceStorageManager: import("@endo/patterns").InterfaceGuard;
-    const withdrawFacet: import("@endo/patterns").InterfaceGuard;
-    const helpers: import("@endo/patterns").InterfaceGuard;
+    let instanceStorageManager: import("@endo/patterns").InterfaceGuard<{
+        getTerms: import("@endo/patterns").MethodGuard;
+        getIssuers: import("@endo/patterns").MethodGuard;
+        getBrands: import("@endo/patterns").MethodGuard;
+        getInstallation: import("@endo/patterns").MethodGuard;
+        getInvitationIssuer: import("@endo/patterns").MethodGuard;
+        saveIssuer: import("@endo/patterns").MethodGuard;
+        makeZoeMint: import("@endo/patterns").MethodGuard;
+        registerFeeMint: import("@endo/patterns").MethodGuard;
+        getInstanceRecord: import("@endo/patterns").MethodGuard;
+        getIssuerRecords: import("@endo/patterns").MethodGuard;
+        getWithdrawFacet: import("@endo/patterns").MethodGuard;
+        initInstanceAdmin: import("@endo/patterns").MethodGuard;
+        deleteInstanceAdmin: import("@endo/patterns").MethodGuard;
+        makeInvitation: import("@endo/patterns").MethodGuard;
+        getRoot: import("@endo/patterns").MethodGuard;
+        getAdminNode: import("@endo/patterns").MethodGuard;
+    }>;
+    let withdrawFacet: import("@endo/patterns").InterfaceGuard<{
+        withdrawPayments: import("@endo/patterns").MethodGuard;
+    }>;
+    let helpers: import("@endo/patterns").InterfaceGuard<{
+        wrapIssuerKitWithZoeMint: import("@endo/patterns").MethodGuard;
+    }>;
 }
 export const BundleCapShape: import("@endo/patterns").Matcher;
 export const BundleShape: import("@endo/patterns").Matcher;
 export const UnwrappedInstallationShape: import("@endo/patterns").Matcher;
 export namespace ZoeStorageManagerIKit {
-    const zoeServiceDataAccess: import("@endo/patterns").InterfaceGuard;
-    const makeOfferAccess: import("@endo/patterns").InterfaceGuard;
-    const startInstanceAccess: import("@endo/patterns").InterfaceGuard;
-    const invitationIssuerAccess: import("@endo/patterns").InterfaceGuard;
+    let zoeServiceDataAccess: import("@endo/patterns").InterfaceGuard<{
+        getTerms: import("@endo/patterns").MethodGuard;
+        getIssuers: import("@endo/patterns").MethodGuard;
+        getBrands: import("@endo/patterns").MethodGuard;
+        getInstallation: import("@endo/patterns").MethodGuard;
+        getInvitationIssuer: import("@endo/patterns").MethodGuard;
+        getBundleIDFromInstallation: import("@endo/patterns").MethodGuard;
+        installBundle: import("@endo/patterns").MethodGuard;
+        installBundleID: import("@endo/patterns").MethodGuard;
+        getPublicFacet: import("@endo/patterns").MethodGuard;
+        getOfferFilter: import("@endo/patterns").MethodGuard;
+        getProposalShapeForInvitation: import("@endo/patterns").MethodGuard;
+    }>;
+    let makeOfferAccess: import("@endo/patterns").InterfaceGuard<{
+        getAssetKindByBrand: import("@endo/patterns").MethodGuard;
+        getInstanceAdmin: import("@endo/patterns").MethodGuard;
+        getProposalShapeForInvitation: import("@endo/patterns").MethodGuard;
+        getInvitationIssuer: import("@endo/patterns").MethodGuard;
+        depositPayments: import("@endo/patterns").MethodGuard;
+    }>;
+    let startInstanceAccess: import("@endo/patterns").InterfaceGuard<{
+        makeZoeInstanceStorageManager: import("@endo/patterns").MethodGuard;
+        unwrapInstallation: import("@endo/patterns").MethodGuard;
+    }>;
+    let invitationIssuerAccess: import("@endo/patterns").InterfaceGuard<{
+        getInvitationIssuer: import("@endo/patterns").MethodGuard;
+    }>;
 }
-export const ZoeServiceI: import("@endo/patterns").InterfaceGuard;
-export const AdminFacetI: import("@endo/patterns").InterfaceGuard;
+export const ZoeServiceI: import("@endo/patterns").InterfaceGuard<{
+    install: import("@endo/patterns").MethodGuard;
+    installBundleID: import("@endo/patterns").MethodGuard;
+    startInstance: import("@endo/patterns").MethodGuard;
+    offer: import("@endo/patterns").MethodGuard;
+    getOfferFilter: import("@endo/patterns").MethodGuard;
+    getInvitationIssuer: import("@endo/patterns").MethodGuard;
+    getFeeIssuer: import("@endo/patterns").MethodGuard;
+    getBrands: import("@endo/patterns").MethodGuard;
+    getIssuers: import("@endo/patterns").MethodGuard;
+    getPublicFacet: import("@endo/patterns").MethodGuard;
+    getTerms: import("@endo/patterns").MethodGuard;
+    getInstallationForInstance: import("@endo/patterns").MethodGuard;
+    getBundleIDFromInstallation: import("@endo/patterns").MethodGuard;
+    getInstallation: import("@endo/patterns").MethodGuard;
+    getInstance: import("@endo/patterns").MethodGuard;
+    getConfiguration: import("@endo/patterns").MethodGuard;
+    getInvitationDetails: import("@endo/patterns").MethodGuard;
+    getProposalShapeForInvitation: import("@endo/patterns").MethodGuard;
+}>;
+export const AdminFacetI: import("@endo/patterns").InterfaceGuard<{
+    getVatShutdownPromise: import("@endo/patterns").MethodGuard;
+    restartContract: import("@endo/patterns").MethodGuard;
+    upgradeContract: import("@endo/patterns").MethodGuard;
+}>;
 export const SeatDataShape: import("@endo/patterns").Matcher;
-export const HandleOfferI: import("@endo/patterns").InterfaceGuard;
+export const HandleOfferI: import("@endo/patterns").InterfaceGuard<{
+    handleOffer: import("@endo/patterns").MethodGuard;
+}>;
 export namespace PriceQuoteShape {
     export { AmountShape as quoteAmount };
-    export const quotePayment: any;
+    export let quotePayment: globalThis.Pattern;
 }
-import { AmountShape } from "@agoric/ertp/src/typeGuards";
+import { AmountShape } from '@agoric/ertp';
 //# sourceMappingURL=typeGuards.d.ts.map

package/src/typeGuards.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAgBA,4DAAuC;AAEvC,qEAAqE;AACrE,+DAAyD;AACzD,mEAAiE;AACjE,iEAA6D;AAC7D,yDAA6C;AAE7C,wEAA8E;AAC9E,+EAGE;AACF,0EAGE;AACF,wEAA8E;AAC9E,yEAGE;AACF,uEAA4E;AAE5E,iEAOE;;;;;;;;;;AAaF,8DAAiD;AAE1C,6EAA4D;AACnE,0DAAmD;;;;;;AA0BnD,2BAA2B;AAC3B,6DAAsE;AAE/D,uDAGN;AAMM,uCAHI,QAAQ,0BAMlB;AAMM,8CAHI,QAAQ,iCAMlB;AAED,sEAKG;AAEH,oEAEG;AAEH,0EAKE;AAEF,4DAAmD;AACnD,+DAIG;AAEH,+DASG;AAEH,kEAA+D;AAE/D,kEAEG;AAEH,+DAAsD;AACtD,kEAA+D;AAC/D,qEAkCG;;;;;;AAiDH,8DAAuD;AACvD,2DAGE;AAEF,0EAUE;;;;;;;AA2DF,kEA6CG;AAEH,kEAIG;AAEH,6DASE;AAEF,mEAKG"}
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAgBA,4DAAuC;AAEvC,qEAAqE;AACrE,+DAAyD;AACzD,mEAAiE;AACjE,iEAA6D;AAC7D,yDAA6C;AAE7C,wEAA8E;AAC9E,+EAGE;AACF,0EAGE;AACF,wEAA8E;AAC9E,yEAGE;AACF,uEAA4E;AAE5E,iEAOE;;;;;;;;;;AAaF,kEAAiD;AAE1C,6EAA4D;AACnE,0DAAmD;;;;;;AA0BnD,2BAA2B;AAC3B,6DAAsE;AAEtE,kEAIG;AAEI,uDAGN;AAMM,uCAHI,QAAQ,GACN,IAAI,IAAI,cAAc,CAKlC;AAMM,8CAHI,QAAQ,GACN,IAAI,IAAI,qBAAqB,CAKzC;AAED,sEAKG;AAEH;;GAEG;AAEH,0EAKE;AAEF,4DAAmD;AACnD;;;;GAIG;AAEH;;;;GASG;AAEH,kEAA+D;AAE/D;;GAEG;AAEH,+DAAsD;AACtD,kEAA+D;AAC/D;;;;;;;;;;;;;;;;;GAkCG;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDH,8DAAuD;AACvD,2DAGE;AAEF,0EAUE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DF;;;;;;;;;;;;;;;;;;;GA6CG;AAEH;;;;GAIG;AAEH,6DASE;AAEF;;GAKG;;;;;4BAjYI,cAAc"}

package/src/typeGuards.js

@@ -90,6 +90,12 @@ export const FullProposalShape = harden({
 /** @see {Proposal} type */
 export const ProposalShape = M.splitRecord({}, FullProposalShape, {});
 
+export const EmptyProposalShape = M.splitRecord({
+  give: {},
+  want: {},
+  exit: { onDemand: null },
+});
+
 export const isOnDemandExitRule = exit => {
   const [exitKey] = Object.keys(exit);
   return exitKey === 'onDemand';
@@ -121,7 +127,7 @@ export const InvitationElementShape = M.splitRecord({
 });
 
 export const OfferHandlerI = M.interface('OfferHandler', {
-  handle: M.call(SeatShape).optional(M.any()).returns(M.string()),
+  handle: M.call(SeatShape).optional(M.any()).returns(M.any()),
 });
 
 export const SeatHandleAllocationsShape = M.arrayOf(
@@ -219,7 +225,7 @@ export const InstanceStorageManagerIKit = harden({
       InstanceHandleShape,
       M.remotable('instanceAdmin'),
     ).returns(M.promise()),
-    deleteInstanceAdmin: M.call(InstanceAdminI).returns(),
+    deleteInstanceAdmin: M.call(InstanceAdminShape).returns(),
     makeInvitation: M.call(InvitationHandleShape, M.string())
       .optional(M.record(), M.pattern())
       .returns(PaymentShape),
@@ -271,10 +277,12 @@ export const ZoeStorageManagerIKit = harden({
     getBundleIDFromInstallation: M.call(InstallationShape).returns(
       M.eref(M.string()),
     ),
-    installBundle: M.call(M.or(InstanceHandleShape, BundleShape)).returns(
-      M.promise(),
-    ),
-    installBundleID: M.call(M.string()).returns(M.promise()),
+    installBundle: M.call(M.or(InstanceHandleShape, BundleShape))
+      .optional(M.string())
+      .returns(M.promise()),
+    installBundleID: M.call(M.string())
+      .optional(M.string())
+      .returns(M.promise()),
 
     getPublicFacet: M.call(InstanceHandleShape).returns(
       M.eref(M.remotable('PublicFacet')),
@@ -305,6 +313,7 @@ export const ZoeStorageManagerIKit = harden({
       IssuerPKeywordRecordShape,
       M.or(InstanceHandleShape, BundleShape),
       M.or(BundleCapShape, BundleShape),
+      M.string(),
     ).returns(M.promise()),
     unwrapInstallation: M.callWhen(M.eref(InstallationShape)).returns(
       UnwrappedInstallationShape,
@@ -316,10 +325,10 @@ export const ZoeStorageManagerIKit = harden({
 });
 
 export const ZoeServiceI = M.interface('ZoeService', {
-  install: M.call(M.any()).returns(M.promise()),
-  installBundleID: M.call(M.string()).returns(M.promise()),
+  install: M.call(M.any()).optional(M.string()).returns(M.promise()),
+  installBundleID: M.call(M.string()).optional(M.string()).returns(M.promise()),
   startInstance: M.call(M.eref(InstallationShape))
-    .optional(IssuerPKeywordRecordShape, M.any(), M.any())
+    .optional(IssuerPKeywordRecordShape, M.record(), M.record(), M.string())
     .returns(M.promise()),
   offer: M.call(M.eref(InvitationShape))
     .optional(ProposalShape, PaymentPKeywordRecordShape, M.any())

package/src/types-ambient.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Alias for RemotableObject
+ */
+type Handle<H extends string> = import("@endo/marshal").RemotableObject<H>;
+type Keyword = string;
+/**
+ * - an opaque handle for an invitation
+ */
+type InvitationHandle = Handle<"Invitation">;
+type IssuerKeywordRecord = Record<Keyword, Issuer<any>>;
+type IssuerPKeywordRecord = Record<Keyword, import("@endo/far").ERef<Issuer<any>>>;
+type BrandKeywordRecord = Record<Keyword, Brand<any>>;
+type StandardTerms = {
+    /**
+     * - record with
+     * keywords keys, issuer values
+     */
+    issuers: IssuerKeywordRecord;
+    /**
+     * - record with keywords
+     * keys, brand values
+     */
+    brands: BrandKeywordRecord;
+};
+type AnyTerms = StandardTerms & Record<string, any>;
+type InstanceRecord = {
+    installation: import("./zoeService/utils.js").Installation<any>;
+    instance: import("./zoeService/utils.js").Instance<any>;
+    /**
+     * - contract parameters
+     */
+    terms: AnyTerms;
+};
+type IssuerRecord<K extends globalThis.AssetKind = globalThis.AssetKind, M extends import("@endo/patterns").Key = import("@endo/patterns").Key> = {
+    brand: Brand<K>;
+    issuer: Issuer<K, M>;
+    assetKind: K;
+    displayInfo?: globalThis.DisplayInfo<K> | undefined;
+};
+type Allocation = Record<Keyword, import("@agoric/ertp/src/types.js").AnyAmount>;
+//# sourceMappingURL=types-ambient.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-ambient.d.ts","sourceRoot":"","sources":["types-ambient.js"],"names":[],"mappings":";;;YAIqD,CAAC,mBAAzC,OAAO,eAAe,EAAE,eAAe,CAAC,CAAC,CAAC;eAI1C,MAAM;;;;wBACN,MAAM,CAAC,YAAY,CAAC;2BACpB,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;4BAC5B,MAAM,CAAC,OAAO,EAAE,OAAO,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;0BACtD,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;;;;;;aAK1B,mBAAmB;;;;;YAEnB,kBAAkB;;gBAGnB,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;kBAGlC,OAAO,uBAAuB,EAAE,YAAY,CAAC,GAAG,CAAC;cACjD,OAAO,uBAAuB,EAAE,QAAQ,CAAC,GAAG,CAAC;;;;WAC7C,QAAQ;;kBASR,CAAC,sDADS,CAAC;WADX,KAAK,CAEL,CAAC,AAFM,CAAC;YACR,MAAM,CACN,CAAC,AADO,EAAE,CAAC,CAAC;eACZ,CAAC;;;kBAKF,MAAM,CAAC,OAAO,EAAE,OAAO,2BAA2B,EAAE,SAAS,CAAC"}

package/src/{types.js → types-ambient.js}

@@ -1,20 +1,15 @@
 // @jessie-check
 
-/// <reference types="ses"/>
-
 /**
  * @template {string} H - the name of the handle
- * @typedef {H & import("@endo/marshal").Remotable} Handle A type constructor for an opaque type
- * identified by the H string. This uses an intersection type
- * ('MyHandle' & {}) to tag the handle's type even though the actual
- * value is just an empty object.
+ * @typedef {import("@endo/marshal").RemotableObject<H>} Handle Alias for RemotableObject
  */
 
 /**
  * @typedef {string} Keyword
  * @typedef {Handle<'Invitation'>} InvitationHandle - an opaque handle for an invitation
  * @typedef {Record<Keyword, Issuer<any>>} IssuerKeywordRecord
- * @typedef {Record<Keyword, ERef<Issuer<any>>>} IssuerPKeywordRecord
+ * @typedef {Record<Keyword, import('@endo/far').ERef<Issuer<any>>>} IssuerPKeywordRecord
  * @typedef {Record<Keyword, Brand<any>>} BrandKeywordRecord
  */
 
@@ -28,24 +23,21 @@
  * @typedef {StandardTerms & Record<string, any>} AnyTerms
  *
  * @typedef {object} InstanceRecord
- * @property {Installation} installation
+ * @property {import('./zoeService/utils.js').Installation<any>} installation
  * @property {import("./zoeService/utils.js").Instance<any>} instance
  * @property {AnyTerms} terms - contract parameters
  */
 
 /**
  * @template {AssetKind} [K=AssetKind]
+ * @template {import("@endo/patterns").Key} [M=import("@endo/patterns").Key] member kind, for Amounts that have member values
  * @typedef {object} IssuerRecord
  * @property {Brand<K>} brand
- * @property {Issuer<K>} issuer
+ * @property {Issuer<K, M>} issuer
  * @property {K} assetKind
  * @property {DisplayInfo<K>} [displayInfo]
- *
- * @typedef {AmountKeywordRecord} Allocation
  */
 
 /**
- * @template {object} [R=unknown] Offer result
- * @template {object} [A=never] Offer args
- * @typedef {Payment<'set'>} Invitation
+ * @typedef {Record<Keyword, import('@agoric/ertp/src/types.js').AnyAmount>} Allocation
  */

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"}