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

package/src/zoeService/utils.d.ts

@@ -1,84 +1,78 @@
-import type { Callable } from '@agoric/internal/src/utils.js';
-import { VatUpgradeResults } from '@agoric/swingset-vat';
-import { Baggage } from '@agoric/vat-data';
+// Ambient types
+import '../types-ambient.js';
+import '../contractFacet/types-ambient.js';
 
-import type { IssuerKeywordRecord, Payment } from './types.js';
+import type { Issuer } from '@agoric/ertp/src/types.js';
+import type { TagContainer } from '@agoric/internal/src/tagged.js';
+import type { Baggage } from '@agoric/swingset-liveslots';
+import type { VatUpgradeResults } from '@agoric/swingset-vat';
+import type { RemotableObject } from '@endo/marshal';
 
 // XXX https://github.com/Agoric/agoric-sdk/issues/4565
 type SourceBundle = Record<string, any>;
 
-type ContractFacet<T extends {} = {}> = {
-  readonly [P in keyof T]: T[P] extends Callable ? T[P] : never;
-};
-
-export type AdminFacet = {
-  // Completion, which is currently any
-  getVatShutdownPromise: () => Promise<any>;
-  upgradeContract: (
-    contractBundleId: string,
-    newPrivateArgs?: any,
-  ) => Promise<VatUpgradeResults>;
-  restartContract: (newPrivateArgs?: any) => Promise<VatUpgradeResults>;
-};
-
 /**
  * Installation of a contract, typed by its start function.
  */
-declare const StartFunction: unique symbol;
-export type Installation<SF> = {
-  getBundle: () => SourceBundle;
-  getBundleLabel: () => string;
-  // because TS is structural, without this the generic is ignored
-  [StartFunction]: SF;
-};
-export type Instance<SF> = Handle<'Instance'> & {
-  // because TS is structural, without this the generic is ignored
-  [StartFunction]: SF;
-};
+export type Installation<SF extends ContractStartFunction | unknown> =
+  TagContainer<SF> &
+    RemotableObject & {
+      getBundle: () => SourceBundle;
+      getBundleLabel: () => string;
+    };
 
-export type InstallationStart<I> = I extends Installation<infer SF>
-  ? SF
-  : never;
+export type Instance<SF extends ContractStartFunction | unknown> =
+  TagContainer<SF> & RemotableObject & Handle<'Instance'>;
+
+export type InstallationStart<I> =
+  I extends Installation<infer SF> ? SF : never;
 
-type ContractStartFunction = (
+export type ContractStartFunction = (
   zcf?: ZCF,
   privateArgs?: {},
   baggage?: Baggage,
 ) => ERef<{ creatorFacet?: {}; publicFacet?: {} }>;
 
-type StartParams<SF> = SF extends ContractStartFunction
-  ? {
-      terms: ReturnType<Parameters<SF>[0]['getTerms']>;
-      privateArgs: Parameters<SF>[1];
-    }
+export type AdminFacet<SF extends ContractStartFunction> = RemotableObject & {
+  // Completion, which is currently any
+  getVatShutdownPromise: () => Promise<any>;
+  upgradeContract: Parameters<SF>[1] extends undefined
+    ? (contractBundleId: string) => Promise<VatUpgradeResults>
+    : (
+        contractBundleId: string,
+        newPrivateArgs: Parameters<SF>[1],
+      ) => Promise<VatUpgradeResults>;
+  restartContract: Parameters<SF>[1] extends undefined
+    ? () => Promise<VatUpgradeResults>
+    : (newPrivateArgs: Parameters<SF>[1]) => Promise<VatUpgradeResults>;
+};
+
+export type StartParams<SF> = SF extends ContractStartFunction
+  ? Parameters<SF>[1] extends undefined
+    ? {
+        terms: ReturnType<ZcfOf<SF>['getTerms']>;
+      }
+    : {
+        terms: ReturnType<ZcfOf<SF>['getTerms']>;
+        privateArgs: Parameters<SF>[1];
+      }
   : never;
 
-type StartResult<S> = S extends (...args: any) => Promise<infer U>
-  ? U
-  : ReturnType<S>;
+type StartResult<S extends (...args: any) => any> = Awaited<ReturnType<S>>;
+type ZcfOf<SF extends ContractStartFunction> = Parameters<SF>[0] extends ZCF
+  ? Parameters<SF>[0]
+  : ZCF<any>;
 
 /**
  * Convenience record for contract start function, merging its result with params.
  */
-export type ContractOf<S> = StartParams<S> & StartResult<S>;
-
-type StartContractInstance<C> = (
-  installation: Installation<C>,
-  issuerKeywordRecord?: IssuerKeywordRecord,
-  terms?: object,
-  privateArgs?: object,
-) => Promise<{
-  creatorFacet: C['creatorFacet'];
-  publicFacet: C['publicFacet'];
-  instance: Instance;
-  creatorInvitation: C['creatorInvitation'];
-  adminFacet: AdminFacet;
-}>;
+export type ContractOf<S extends (...args: any) => any> = StartParams<S> &
+  StartResult<S>;
 
 /** The result of `startInstance` */
-export type StartedInstanceKit<SF> = {
+export type StartedInstanceKit<SF extends ContractStartFunction> = {
   instance: Instance<SF>;
-  adminFacet: AdminFacet;
+  adminFacet: AdminFacet<SF>;
   // theses are empty by default. the return type will override
   creatorFacet: {};
   publicFacet: {};
@@ -104,17 +98,22 @@ export type StartedInstanceKit<SF> = {
  * the creator facet, public facet, and creator invitation as defined
  * by the contract.
  */
+// XXX SF should extend ContractStartFunction but doing that triggers a bunch of tech debt type errors
 export type StartInstance = <SF>(
   installation: Installation<SF> | PromiseLike<Installation<SF>>,
-  issuerKeywordRecord?: IssuerKeywordRecord,
+  issuerKeywordRecord?: Record<Keyword, Issuer<any>>,
   // 'brands' and 'issuers' need not be passed in; Zoe provides them as StandardTerms
   terms?: Omit<StartParams<SF>['terms'], 'brands' | 'issuers'>,
+  // @ts-expect-error XXX
   privateArgs?: Parameters<SF>[1],
   label?: string,
+  // @ts-expect-error XXX
 ) => Promise<StartedInstanceKit<SF>>;
 
+// XXX SF should extend ContractStartFunction but doing that triggers a bunch of tech debt type errors
 export type GetPublicFacet = <SF>(
   instance: Instance<SF> | PromiseLike<Instance<SF>>,
+  // @ts-expect-error XXX
 ) => Promise<StartResult<SF>['publicFacet']>;
 
 export type GetTerms = <SF>(instance: Instance<SF>) => Promise<

package/src/zoeService/utils.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test-d.d.ts.map

package/src/zoeService/utils.test-d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test-d.d.ts","sourceRoot":"","sources":["utils.test-d.ts"],"names":[],"mappings":""}

package/src/zoeService/utils.test-d.ts

@@ -0,0 +1,33 @@
+import type { StartedInstanceKit } from './utils';
+
+const someContractStartFn = (
+  zcf: ZCF,
+  privateArgs: { someNumber: number; someString: string },
+) => ({});
+
+type PsmInstanceKit = StartedInstanceKit<typeof someContractStartFn>;
+
+const psmInstanceKit: PsmInstanceKit = null as any;
+
+// @ts-expect-error missing privateArgs argument
+void psmInstanceKit.adminFacet.restartContract();
+
+const partial = {
+  someNumber: 1,
+};
+// @ts-expect-error missing member of privateArgs argument
+void psmInstanceKit.adminFacet.restartContract(partial);
+
+// valid privateArgs now with 'marshaller'
+void psmInstanceKit.adminFacet.restartContract({
+  ...partial,
+  someString: 'str',
+});
+
+// @ts-expect-error missing member of privateArgs argument
+void psmInstanceKit.adminFacet.upgradeContract('whatever', partial);
+// valid privateArgs now with 'marshaller'
+void psmInstanceKit.adminFacet.upgradeContract('whatever', {
+  ...partial,
+  someString: 'str',
+});

package/src/zoeService/zoe.d.ts

@@ -1,14 +1,13 @@
-export type Baggage = import('@agoric/vat-data').Baggage;
 export type ZoeKit = ReturnType<typeof makeDurableZoeKit>;
 /**
- * Create an durable instance of Zoe.
+ * Create a durable instance of Zoe.
  *
  * @param {object} options
  * @param {Baggage} options.zoeBaggage - the baggage for Zoe durability. Must be provided by caller
  * @param {Promise<VatAdminSvc> | VatAdminSvc} [options.vatAdminSvc] - The vatAdmin Service, which carries the
  * power to create a new vat. If it's not available when makeZoe() is called, it
  * must be provided later using setVatAdminService().
- * @param {ShutdownWithFailure} [options.shutdownZoeVat] - a function to
+ * @param {import('@agoric/swingset-vat').ShutdownWithFailure} [options.shutdownZoeVat] - a function to
  * shutdown the Zoe Vat. This function needs to use the vatPowers
  * available to a vat.
  * @param {FeeIssuerConfig} [options.feeIssuerConfig]
@@ -16,15 +15,18 @@ export type ZoeKit = ReturnType<typeof makeDurableZoeKit>;
  */
 export function makeDurableZoeKit({ zoeBaggage, vatAdminSvc, shutdownZoeVat, feeIssuerConfig, zcfSpec, }: {
     zoeBaggage: Baggage;
-    vatAdminSvc?: import("@agoric/swingset-vat").VatAdminSvc | Promise<import("@agoric/swingset-vat").VatAdminSvc> | undefined;
+    vatAdminSvc?: VatAdminSvc | Promise<VatAdminSvc> | undefined;
     shutdownZoeVat?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined;
     feeIssuerConfig?: FeeIssuerConfig | undefined;
     zcfSpec?: ZCFSpec | undefined;
 }): {
     zoeService: ZoeService;
+    zoeConfigFacet: import("@endo/exo").Guarded<{
+        updateZcfBundleId(bundleId: any): void;
+    }>;
     /** @type {FeeMintAccess} */
     feeMintAccess: FeeMintAccess;
-    setVatAdminService: ((lateVatAdminSvc: any) => void) & import("@endo/eventual-send").RemotableBrand<{}, (lateVatAdminSvc: any) => void>;
+    setVatAdminService: ((lateVatAdminSvc: any) => void) & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, (lateVatAdminSvc: any) => void>;
 };
 /**
  * @deprecated
@@ -36,16 +38,20 @@ export function makeDurableZoeKit({ zoeBaggage, vatAdminSvc, shutdownZoeVat, fee
  * @param {Promise<VatAdminSvc> | VatAdminSvc} [vatAdminSvc] - The vatAdmin Service, which carries the
  * power to create a new vat. If it's not available when makeZoe() is called, it
  * must be provided later using setVatAdminService().
- * @param {ShutdownWithFailure} [shutdownZoeVat] - a function to
+ * @param {import('@agoric/swingset-vat').ShutdownWithFailure} [shutdownZoeVat] - a function to
  * shutdown the Zoe Vat. This function needs to use the vatPowers
  * available to a vat.
  * @param {FeeIssuerConfig} [feeIssuerConfig]
  * @param {ZCFSpec} [zcfSpec] - Pointer to the contract facet bundle.
  */
-export function makeZoeKit(vatAdminSvc?: import("@agoric/swingset-vat").VatAdminSvc | Promise<import("@agoric/swingset-vat").VatAdminSvc> | undefined, shutdownZoeVat?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined, feeIssuerConfig?: FeeIssuerConfig | undefined, zcfSpec?: ZCFSpec | undefined): {
+export function makeZoeKit(vatAdminSvc?: VatAdminSvc | Promise<VatAdminSvc> | undefined, shutdownZoeVat?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined, feeIssuerConfig?: FeeIssuerConfig | undefined, zcfSpec?: ZCFSpec | undefined): {
     zoeService: ZoeService;
+    zoeConfigFacet: import("@endo/exo").Guarded<{
+        updateZcfBundleId(bundleId: any): void;
+    }>;
     /** @type {FeeMintAccess} */
     feeMintAccess: FeeMintAccess;
-    setVatAdminService: ((lateVatAdminSvc: any) => void) & import("@endo/eventual-send").RemotableBrand<{}, (lateVatAdminSvc: any) => void>;
+    setVatAdminService: ((lateVatAdminSvc: any) => void) & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, (lateVatAdminSvc: any) => void>;
 };
+import type { Baggage } from '@agoric/vat-data';
 //# sourceMappingURL=zoe.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"zoe.d.ts","sourceRoot":"","sources":["zoe.js"],"names":[],"mappings":"sBA6Bc,OAAO,kBAAkB,EAAE,OAAO;qBAwOnC,WAAW,wBAAwB,CAAC;AApOjD;;;;;;;;;;;;;GAaG;AACH;IAV4B,UAAU,EAA3B,OAAO;IACsC,WAAW;IAG1B,cAAc;IAGlB,eAAe;IACvB,OAAO;;;IAoLhC,4BAA4B;mBAAjB,aAAa;;EAK3B;AAED;;;;;;;;;;;;;;;GAeG;AACH;;IAvBI,4BAA4B;mBAAjB,aAAa;;EA8BxB"}
+{"version":3,"file":"zoe.d.ts","sourceRoot":"","sources":["zoe.js"],"names":[],"mappings":"qBAiSa,UAAU,CAAC,OAAO,iBAAiB,CAAC;AA/PjD;;;;;;;;;;;;;GAaG;AACH,0GAVG;IAAyB,UAAU,EAA3B,OAAO;IACsC,WAAW;IAGK,cAAc;IAGjD,eAAe;IACvB,OAAO;CACnC;;;;;IA8MG,4BAA4B;mBAAjB,aAAa;;EAK3B;AAED;;;;;;;;;;;;;;;GAeG;AACH;;;;;IAvBI,4BAA4B;mBAAjB,aAAa;;EA8BxB;6BA7PuB,kBAAkB"}

package/src/zoeService/zoe.js

@@ -1,4 +1,5 @@
 // @jessie-check
+/* eslint @typescript-eslint/no-floating-promises: "warn" */
 
 /**
  * Zoe uses ERTP, the Electronic Rights Transfer Protocol
@@ -9,15 +10,15 @@
  * currently. When the brand has an assetKind itself, AmountMath will
  * validate that.
  */
-// Ambient types. https://github.com/Agoric/agoric-sdk/issues/6512
-import '@agoric/ertp/exported.js';
-import '@agoric/store/exported.js';
 
-import '../internal-types.js';
+/// <reference types="@agoric/internal/exported" />
+/// <reference types="@agoric/notifier/exported.js" />
+/// <reference path="../internal-types.js" />
 
 import { E } from '@endo/eventual-send';
 import { Far } from '@endo/marshal';
 import { makeScalarBigMapStore, prepareExo } from '@agoric/vat-data';
+import { M } from '@agoric/store';
 
 import { makeZoeStorageManager } from './zoeStorageManager.js';
 import { makeStartInstance } from './startInstance.js';
@@ -27,19 +28,19 @@ import { getZcfBundleCap } from './createZCFVat.js';
 import { defaultFeeIssuerConfig, prepareFeeMint } from './feeMint.js';
 import { ZoeServiceI } from '../typeGuards.js';
 
-/** @typedef {import('@agoric/vat-data').Baggage} Baggage */
+/** @import {Baggage} from '@agoric/vat-data' */
 
 const { Fail } = assert;
 
 /**
- * Create an durable instance of Zoe.
+ * Create a durable instance of Zoe.
  *
  * @param {object} options
  * @param {Baggage} options.zoeBaggage - the baggage for Zoe durability. Must be provided by caller
  * @param {Promise<VatAdminSvc> | VatAdminSvc} [options.vatAdminSvc] - The vatAdmin Service, which carries the
  * power to create a new vat. If it's not available when makeZoe() is called, it
  * must be provided later using setVatAdminService().
- * @param {ShutdownWithFailure} [options.shutdownZoeVat] - a function to
+ * @param {import('@agoric/swingset-vat').ShutdownWithFailure} [options.shutdownZoeVat] - a function to
  * shutdown the Zoe Vat. This function needs to use the vatPowers
  * available to a vat.
  * @param {FeeIssuerConfig} [options.feeIssuerConfig]
@@ -52,16 +53,22 @@ const makeDurableZoeKit = ({
   feeIssuerConfig = defaultFeeIssuerConfig,
   zcfSpec = { name: 'zcf' },
 }) => {
+  /** @type {BundleCap} */
   let zcfBundleCap;
 
   const saveBundleCap = () => {
-    E.when(
+    void E.when(
       Promise.all([vatAdminSvc, getZcfBundleCap(zcfSpec, vatAdminSvc)]),
       ([vatAdminService, bundleCap]) => {
         zcfBundleCap = bundleCap;
 
-        zoeBaggage.init('vatAdminSvc', vatAdminService);
-        zoeBaggage.init('zcfBundleCap', zcfBundleCap);
+        if (!zoeBaggage.has('vatAdminSvc')) {
+          zoeBaggage.init('vatAdminSvc', vatAdminService);
+          zoeBaggage.init('zcfBundleCap', zcfBundleCap);
+        } else {
+          zoeBaggage.set('vatAdminSvc', vatAdminService);
+          zoeBaggage.set('zcfBundleCap', zcfBundleCap);
+        }
       },
     );
   };
@@ -168,6 +175,26 @@ const makeDurableZoeKit = ({
     });
   };
 
+  const ZoeConfigI = M.interface('ZoeConfigFacet', {
+    updateZcfBundleId: M.call(M.string()).returns(),
+  });
+
+  const zoeConfigFacet = prepareExo(zoeBaggage, 'ZoeConfigFacet', ZoeConfigI, {
+    updateZcfBundleId(bundleId) {
+      void E.when(
+        getZcfBundleCap({ id: bundleId }, vatAdminSvc),
+        bundleCap => {
+          zcfBundleCap = bundleCap;
+          zoeBaggage.set('zcfBundleCap', zcfBundleCap);
+        },
+        e => {
+          console.error('🚨 unable to update ZCF Bundle: ', e);
+          throw e;
+        },
+      );
+    },
+  });
+
   /** @type {ZoeService} */
   const zoeService = prepareExo(zoeBaggage, 'ZoeService', ZoeServiceI, {
     install(bundleId, bundleLabel) {
@@ -223,6 +250,7 @@ const makeDurableZoeKit = ({
 
   return harden({
     zoeService,
+    zoeConfigFacet,
     /** @type {FeeMintAccess} */
     // @ts-expect-error cast
     feeMintAccess: feeMintKit.feeMintAccess,
@@ -240,7 +268,7 @@ const makeDurableZoeKit = ({
  * @param {Promise<VatAdminSvc> | VatAdminSvc} [vatAdminSvc] - The vatAdmin Service, which carries the
  * power to create a new vat. If it's not available when makeZoe() is called, it
  * must be provided later using setVatAdminService().
- * @param {ShutdownWithFailure} [shutdownZoeVat] - a function to
+ * @param {import('@agoric/swingset-vat').ShutdownWithFailure} [shutdownZoeVat] - a function to
  * shutdown the Zoe Vat. This function needs to use the vatPowers
  * available to a vat.
  * @param {FeeIssuerConfig} [feeIssuerConfig]

package/src/zoeService/zoeSeat.d.ts

@@ -1,56 +1,26 @@
-export function makeZoeSeatAdminFactory(baggage: MapStore<string, unknown>): (initialAllocation: AmountKeywordRecord, proposal: ProposalRecord, instanceAdminHelper: InstanceAdminHelper, withdrawFacet: WithdrawFacet, exitObj?: ERef<ExitObj> | undefined, offerResultIsUndefined?: boolean | undefined) => {
-    zoeSeatAdmin: {
-        replaceAllocation(replacementAllocation: any): void;
-        exit(completion: any): void;
-        fail(reason: any): void;
-        /** @param {HandleOfferResult} result */
-        resolveExitAndResult({ offerResultPromise, exitObj }: HandleOfferResult): void;
-        getExitSubscriber(): {
-            subscribeAfter(publishCount?: bigint): Promise<any>;
-            getUpdateSince(updateCount: any): any;
-        };
-        finalPayouts(payments: any): Promise<void>;
-    };
-    userSeat: {
-        getProposal(): Promise<ProposalRecord>;
-        getPayouts(): Promise<{}>;
+export function makeZoeSeatAdminFactory(baggage: import("@agoric/vat-data").Baggage): (initialAllocation: Allocation, proposal: ProposalRecord, instanceAdminHelper: InstanceAdminHelper, withdrawFacet: WithdrawFacet, exitObj?: globalThis.ERef<ExitObj> | undefined, offerResultIsUndefined?: boolean | undefined) => {
+    userSeat: 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>;
-    };
-} & import("@endo/eventual-send").RemotableBrand<{}, {
-    zoeSeatAdmin: {
+        hasExited(): Promise<any>;
+        tryExit(): Promise<any>;
+        numWantsSatisfied(): Promise<any>;
+        getExitSubscriber(): any;
+        getFinalAllocation(): any;
+    }>;
+    zoeSeatAdmin: import("@endo/exo").Guarded<{
         replaceAllocation(replacementAllocation: any): void;
         exit(completion: any): void;
         fail(reason: any): void;
         /** @param {HandleOfferResult} result */
         resolveExitAndResult({ offerResultPromise, exitObj }: HandleOfferResult): void;
-        getExitSubscriber(): {
+        getExitSubscriber(): import("@endo/exo").Guarded<{
             subscribeAfter(publishCount?: bigint): Promise<any>;
             getUpdateSince(updateCount: any): any;
-        };
+        }>;
         finalPayouts(payments: any): Promise<void>;
-    };
-    userSeat: {
-        getProposal(): Promise<ProposalRecord>;
-        getPayouts(): Promise<{}>;
-        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>;
-    };
-}>;
+    }>;
+};
 //# sourceMappingURL=zoeSeat.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"zoeSeat.d.ts","sourceRoot":"","sources":["zoeSeat.js"],"names":[],"mappings":"AAiEO;;;;;QAgIC,wCAAwC;8DAA5B,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;QAA7B,wCAAwC;8DAA5B,iBAAiB;;;;;;;;;;;;;;;;;;;;;GAmJpC"}
+{"version":3,"file":"zoeSeat.d.ts","sourceRoot":"","sources":["zoeSeat.js"],"names":[],"mappings":"AAoDO,iDAFI,OAAO,kBAAkB,EAAE,OAAO,uBAwWhC,UAAU,YACV,cAAc,uBACd,mBAAmB,iBACnB,aAAa;;;;;;;;;;;;;;;;QAzIlB,wCAAwC;8DAA5B,iBAAiB;;;;;;;EAoKpC"}