Durable ZCF

packages/ERTP/test/swingsetTests/ertpService/vat-ertp-service.js

@@ -9,7 +9,7 @@ import {
 
 import { AssetKind, makeDurableIssuerKit, vivifyIssuerKit } from '../../../src';
 
-function vivifyErtpService(baggage, exitVatWithFailure) {
+export const vivifyErtpService = (baggage, exitVatWithFailure) => {
   const issuerBaggageSet = provideDurableSetStore(baggage, 'BaggageSet');
   const ertpService = vivifySingleton(baggage, 'ERTPService', {
     makeIssuerKit: (
@@ -38,7 +38,8 @@ function vivifyErtpService(baggage, exitVatWithFailure) {
   }
 
   return ertpService;
-}
+};
+harden(vivifyErtpService);
 
 export const buildRootObject = async (vatPowers, _vatParams, baggage) => {
   const ertpService = vivifyErtpService(baggage, vatPowers.exitVatWithFailure);

packages/SwingSet/src/supervisors/supervisor-helper.js

@@ -36,7 +36,7 @@ function makeSupervisorDispatch(dispatch) {
         () => harden(['ok', null, null]),
         err => {
           // TODO react more thoughtfully, maybe terminate the vat
-          console.log(`error ${err} during vat dispatch() of ${delivery}`);
+          console.log(`error [${err}] during vat dispatch() of ${delivery}`);
           return harden(['error', `${err}`, null]);
         },
       );

packages/governance/test/unitTests/test-paramGovernance.js

@@ -9,7 +9,6 @@ import bundleSource from '@endo/bundle-source';
 import buildManualTimer from '@agoric/zoe/tools/manualTimer.js';
 import { makeFakeVatAdmin } from '@agoric/zoe/tools/fakeVatAdmin.js';
 import { E } from '@endo/eventual-send';
-import { makeLoopback } from '@endo/captp';
 
 import { resolve as importMetaResolve } from 'import-meta-resolve';
 import { MALLEABLE_NUMBER } from '../swingsetTests/contractGovernor/governedContract.js';
@@ -34,7 +33,7 @@ const voteCounterBundleP = makeBundle(voteCounterRoot);
 const governedBundleP = makeBundle(governedRoot);
 
 const setUpZoeForTest = async setJig => {
-  const { makeFar } = makeLoopback('zoeTest');
+  const makeFar = o => o;
 
   /**
    * These properties will be assigned by `setJig` in the contract.
@@ -44,7 +43,6 @@ const setUpZoeForTest = async setJig => {
    * @property {IssuerRecord} runIssuerRecord
    * @property {IssuerRecord} govIssuerRecord
    */
-
   const { zoeService, feeMintAccess: nonFarFeeMintAccess } = makeZoeKit(
     makeFakeVatAdmin(setJig, o => makeFar(o)).admin,
   );

packages/vat-data/src/kind-utils.js

@@ -2,6 +2,10 @@ import { provide } from '@agoric/store';
 import { defineDurableKind, makeKindHandle } from './vat-data-bindings.js';
 
 /** @template L,R @typedef {import('@endo/eventual-send').RemotableBrand<L, R>} RemotableBrand */
+/** @typedef {import('@agoric/store').MapStore<string,unknown>} Baggage */
+/** @template T @typedef {import('./types.js').DefineKindOptions<T>} DefineKindOptions */
+/** @template T @typedef {import('./types.js').KindFacet<T>} KindFacet */
+/** @typedef {import('./types.js').DurableKindHandle} DurableKindHandle */
 
 const { entries, fromEntries } = Object;
 
@@ -12,6 +16,11 @@ export const dropContext =
 // @ts-expect-error TODO statically recognize harden
 harden(dropContext);
 
+/**
+ * @param {Baggage} baggage
+ * @param {string} kindName
+ * @returns {DurableKindHandle}
+ */
 export const provideKindHandle = (baggage, kindName) =>
   provide(baggage, `${kindName}_kindHandle`, () => makeKindHandle(kindName));
 // @ts-expect-error TODO statically recognize harden
@@ -62,14 +71,37 @@ export const objectMap = (original, mapFn) => {
   return /** @type {Record<K, U>} */ (harden(fromEntries(mapEnts)));
 };
 
-/** @typedef {import('@agoric/store').MapStore<string,unknown>} Baggage */
+/**
+ * @template P,S,B
+ * @param {Baggage} baggage
+ * @param {string} kindName
+ * @param {(...args: P[]) => S} init
+ * @param {B} behavior
+ * @param {DefineKindOptions<unknown>} [options]
+ * @returns {(...args: P[]) => KindFacet<B>}
+ */
+export const vivifyKind = (
+  baggage,
+  kindName,
+  init,
+  behavior,
+  options = undefined,
+) =>
+  defineDurableKind(
+    provideKindHandle(baggage, kindName),
+    init,
+    behavior,
+    options,
+  );
+// @ts-expect-error TODO statically recognize harden
+harden(vivifyKind);
 
 /**
  * @template T
  * @param {Baggage} baggage
  * @param {string} kindName
  * @param {T} methods
- * @param {import('./types.js').DefineKindOptions<unknown>} [options]
+ * @param {DefineKindOptions<unknown>} [options]
  * @returns {T & RemotableBrand<{}, T>}
  */
 export const vivifySingleton = (
@@ -78,10 +110,10 @@ export const vivifySingleton = (
   methods,
   options = undefined,
 ) => {
-  const kindHandle = provideKindHandle(baggage, kindName);
   const behavior = objectMap(methods, dropContext);
-  const makeSingleton = defineDurableKind(
-    kindHandle,
+  const makeSingleton = vivifyKind(
+    baggage,
+    kindName,
     () => ({}),
     behavior,
     options,

packages/vat-data/src/types.d.ts

@@ -43,7 +43,6 @@ export type DurableKindHandle = DurableKindHandleClass;
 type DefineKindOptions<C> = {
   finish?: (context: C) => void;
   durable?: boolean;
-  fakeDurable?: boolean;
 };
 
 export type VatData = {

packages/vats/src/core/basic-behaviors.js

@@ -281,9 +281,14 @@ export const installBootContracts = async ({
     mintHolder,
     walletFactory,
   })) {
+    // This really wants to be E(vatAdminSvc).getBundleIDByName, but it's
+    // good enough to do D(vatAdmin).getBundleIDByName
     const bundleCap = D(vatAdmin).getNamedBundleCap(name);
+
     const bundle = D(bundleCap).getBundle();
-    producer.resolve(E(zoe).install(bundle));
+    // TODO (#4374) this should be E(zoe).installBundleID(bundleID);
+    const installation = E(zoe).install(bundle);
+    producer.resolve(installation);
   }
 };
 

packages/vats/test/test-boot.js

@@ -108,19 +108,22 @@ const testRole = (ROLE, governanceActions) => {
       fakeBundleCaps.set(bundleCap, name);
       return bundleCap;
     };
-    const createVat = bundleCap => {
+    const createVat = (bundleCap, options) => {
       const name = fakeBundleCaps.get(bundleCap);
       assert(name);
       switch (name) {
         case 'zcf':
-          return fakeVatAdmin.createVat(zcfBundleCap);
+          return fakeVatAdmin.createVat(zcfBundleCap, options);
         default: {
           const buildRoot = vatRoots[name];
           if (!buildRoot) {
             throw Error(`TODO: load vat ${name}`);
           }
-          const vatParameters = {};
+          const vatParameters = { ...options?.vatParameters };
           if (name === 'zoe') {
+            // basic-behaviors.js:buildZoe() provides hard-coded zcf BundleName
+            // and vat-zoe.js ignores vatParameters, but this would be the
+            // preferred way to pass the name.
             vatParameters.zcfBundleName = 'zcf';
           }
           return { root: buildRoot({}, vatParameters), admin: {} };

packages/wallet/api/test/attestationExample.js

@@ -2,6 +2,7 @@
 import '@agoric/zoe/exported.js';
 import { AmountMath } from '@agoric/ertp';
 import { E } from '@endo/eventual-send';
+import { Far } from '@endo/marshal';
 
 /** @param {ZCF} zcf */
 export const start = async zcf => {
@@ -53,12 +54,12 @@ export const start = async zcf => {
 
   const getCallHistory = () => callHistory;
 
-  const publicFacet = {
+  const publicFacet = Far('attestation public facet', {
     mintAttestation,
     makeWantAttInvitation,
     makeReturnAttInvitation,
     getCallHistory,
-  };
+  });
 
   return harden({ publicFacet });
 };

packages/zoe/src/contractFacet/allocationMath.js

@@ -1,7 +1,8 @@
 // @ts-check
-import { assert, details as X } from '@agoric/assert';
 import { AmountMath } from '@agoric/ertp';
 
+const { details: X } = assert;
+
 /**
  * @callback Operation
  *
@@ -37,7 +38,7 @@ const doOperation = (allocation, amountKeywordRecord, operationFn) => {
     })
     .filter(([_keyword, result]) => result !== undefined);
 
-  return Object.fromEntries(entries);
+  return harden(Object.fromEntries(entries));
 };
 
 /** @type {Operation} */

packages/zoe/src/contractFacet/internal-types.js

@@ -6,10 +6,10 @@
 
 /**
  * @typedef ZCFZygote
- * @property {(bundleOrBundleCap: SourceBundle | BundleCap) => void} evaluateContract
  * @property {(instanceAdminFromZoe: ERef<ZoeInstanceAdmin>,
  *     instanceRecordFromZoe: InstanceRecord,
  *     issuerStorageFromZoe: IssuerRecords,
  *     privateArgs?: object,
  * ) => Promise<ExecuteContractResult>} startContract
+ * @property {(privateArgs?: object) => void} restartContract
  */

packages/zoe/src/contractFacet/offerHandlerStorage.js

@@ -2,23 +2,56 @@
 
 import { makeWeakStore } from '@agoric/store';
 import { ToFarFunction } from '@endo/marshal';
+import { canBeDurable, provideDurableWeakMapStore } from '@agoric/vat-data';
 
-import { makeHandle } from '../makeHandle.js';
+import { defineDurableHandle } from '../makeHandle.js';
 
-export const makeOfferHandlerStorage = () => {
+export const makeOfferHandlerStorage = zcfBaggage => {
+  const makeInvitationHandle = defineDurableHandle(zcfBaggage, 'Invitation');
   /** @type {WeakStore<InvitationHandle, OfferHandler>} */
-  const invitationHandleToHandler = makeWeakStore('invitationHandle');
+
+  // ZCF needs to ephemerally hold on to ephemeral handlers, and durably hold
+  // onto handlers that are intended to be durable. We keep two stores and store
+  // each handler in the right one. When retrieving, we look for them in both.
+  // If Zoe restarts, the ephemeral ones will be lost, and the durable ones will
+  // survive.
+  const invitationHandleToEphemeralHandler = makeWeakStore(
+    'invitationHandleToEphemeralHandler',
+  );
+  /** @type {WeakStore<InvitationHandle, OfferHandler>} */
+  const invitationHandleToDurableHandler = provideDurableWeakMapStore(
+    zcfBaggage,
+    'invitationHandleToDurableHandler',
+  );
 
   /** @type {(offerHandler: OfferHandler) => InvitationHandle} */
   const storeOfferHandler = offerHandler => {
-    const farOfferHandler = ToFarFunction('offerHandler', offerHandler);
-    const invitationHandle = makeHandle('Invitation');
-    invitationHandleToHandler.init(invitationHandle, farOfferHandler);
+    if (typeof offerHandler === 'function') {
+      offerHandler = ToFarFunction('offerHandler', offerHandler);
+    }
+    const invitationHandleToHandler = canBeDurable(offerHandler)
+      ? invitationHandleToDurableHandler
+      : invitationHandleToEphemeralHandler;
+
+    const invitationHandle = makeInvitationHandle();
+    invitationHandleToHandler.init(invitationHandle, offerHandler);
     return invitationHandle;
   };
 
-  /** @type {(invitationHandle: InvitationHandle) => OfferHandler} */
-  const takeOfferHandler = invitationHandle => {
+  /**
+   * @type {(invitationHandle: InvitationHandle, details?: Details) => OfferHandler}
+   */
+  const takeOfferHandler = (
+    invitationHandle,
+    details = 'offerHandler may not have survived upgrade',
+  ) => {
+    let invitationHandleToHandler;
+    if (invitationHandleToDurableHandler.has(invitationHandle)) {
+      invitationHandleToHandler = invitationHandleToDurableHandler;
+    } else {
+      assert(invitationHandleToEphemeralHandler.has(invitationHandle), details);
+      invitationHandleToHandler = invitationHandleToEphemeralHandler;
+    }
     const offerHandler = invitationHandleToHandler.get(invitationHandle);
     invitationHandleToHandler.delete(invitationHandle);
     return offerHandler;

packages/zoe/src/contractFacet/types.js

@@ -84,7 +84,7 @@
  */
 
 /**
- * @template {object} [OR=any] OR is OfferResult
+ * @template {object} [OR=unknown] OR is OfferResult
  * @callback MakeInvitation
  *
  * Make a credible Zoe invitation for a particular smart contract
@@ -188,7 +188,7 @@
  * @typedef {object} ZCFSeat
  * @property {() => void} exit
  * @property {ZCFSeatFail} fail
- * @property {() => Notifier<Allocation>} getNotifier
+ * @property {() => Promise<Notifier<Allocation>>} getNotifier
  * @property {() => boolean} hasExited
  * @property {() => ProposalRecord} getProposal
  * @property {ZCFGetAmountAllocated} getAmountAllocated
@@ -206,11 +206,13 @@
  */
 
 /**
- * @template {object} [OR=any]
- * @callback OfferHandler
- * @param {ZCFSeat} seat
- * @param {object=} offerArgs
- * @returns {OR}
+ * @template {object} OR Offer results
+ * @typedef {(seat: ZCFSeat, offerArgs?: object) => OR} HandleOffer
+ */
+
+/**
+ * @template {object} [OR=unknown] Offer results
+ * @typedef {HandleOffer<OR> | { handle: HandleOffer<OR> }} OfferHandler
  */
 
 /**