@agoric/swingset-liveslots 0.10.3-dev-b282e92.0 → 0.10.3-dev-0cd32a5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/swingset-liveslots",
-  "version": "0.10.3-dev-b282e92.0+b282e92",
+  "version": "0.10.3-dev-0cd32a5.0+0cd32a5",
   "description": "SwingSet ocap support layer",
   "type": "module",
   "main": "src/index.js",
@@ -17,8 +17,8 @@
     "lint:eslint": "eslint ."
   },
   "dependencies": {
-    "@agoric/internal": "0.3.3-dev-b282e92.0+b282e92",
-    "@agoric/store": "0.9.3-dev-b282e92.0+b282e92",
+    "@agoric/internal": "0.3.3-dev-0cd32a5.0+0cd32a5",
+    "@agoric/store": "0.9.3-dev-0cd32a5.0+0cd32a5",
     "@endo/env-options": "^1.1.6",
     "@endo/errors": "^1.2.5",
     "@endo/eventual-send": "^1.2.5",
@@ -32,7 +32,7 @@
     "@endo/promise-kit": "^1.1.5"
   },
   "devDependencies": {
-    "@agoric/kmarshal": "0.1.1-dev-b282e92.0+b282e92",
+    "@agoric/kmarshal": "0.1.1-dev-0cd32a5.0+0cd32a5",
     "ava": "^5.3.0"
   },
   "files": [
@@ -68,5 +68,5 @@
   "typeCoverage": {
     "atLeast": 75.1
   },
-  "gitHead": "b282e923866829ba364c059429faa971fa2c9d6a"
+  "gitHead": "0cd32a59f24dbea365f80be5ac3880db9234e4d1"
 }

package/test/exo-utils.js

@@ -0,0 +1,70 @@
+import { provideLazy as provide } from '@agoric/store';
+
+// Partially duplicates @agoric/vat-data to avoid circular dependencies.
+export const makeExoUtils = VatData => {
+  const { defineDurableKind, makeKindHandle, watchPromise } = VatData;
+
+  const provideKindHandle = (baggage, kindName) =>
+    provide(baggage, `${kindName}_kindHandle`, () => makeKindHandle(kindName));
+
+  const emptyRecord = harden({});
+  const initEmpty = () => emptyRecord;
+
+  const defineDurableExoClass = (
+    kindHandle,
+    interfaceGuard,
+    init,
+    methods,
+    options,
+  ) =>
+    defineDurableKind(kindHandle, init, methods, {
+      ...options,
+      thisfulMethods: true,
+      interfaceGuard,
+    });
+
+  const prepareExoClass = (
+    baggage,
+    kindName,
+    interfaceGuard,
+    init,
+    methods,
+    options = undefined,
+  ) =>
+    defineDurableExoClass(
+      provideKindHandle(baggage, kindName),
+      interfaceGuard,
+      init,
+      methods,
+      options,
+    );
+
+  const prepareExo = (
+    baggage,
+    kindName,
+    interfaceGuard,
+    methods,
+    options = undefined,
+  ) => {
+    const makeSingleton = prepareExoClass(
+      baggage,
+      kindName,
+      interfaceGuard,
+      initEmpty,
+      methods,
+      options,
+    );
+    return provide(baggage, `the_${kindName}`, () => makeSingleton());
+  };
+
+  return {
+    defineDurableKind,
+    makeKindHandle,
+    watchPromise,
+
+    provideKindHandle,
+    defineDurableExoClass,
+    prepareExoClass,
+    prepareExo,
+  };
+};

package/test/handled-promises.test.js

@@ -2,7 +2,7 @@ import test from 'ava';
 
 import { Fail } from '@endo/errors';
 import { Far } from '@endo/marshal';
-import { M, provideLazy as provide } from '@agoric/store';
+import { M } from '@agoric/store';
 import { makePromiseKit } from '@endo/promise-kit';
 // Disabled to avoid circular dependencies.
 // import { makeStoreUtils } from '@agoric/vat-data/src/vat-data-bindings.js';
@@ -10,79 +10,11 @@ import { makePromiseKit } from '@endo/promise-kit';
 import { kslot, kser } from '@agoric/kmarshal';
 import { setupTestLiveslots } from './liveslots-helpers.js';
 import { makeResolve, makeReject } from './util.js';
+import { makeExoUtils } from './exo-utils.js';
 
 // eslint-disable-next-line no-unused-vars
 const compareEntriesByKey = ([ka], [kb]) => (ka < kb ? -1 : 1);
 
-// Paritally duplicates @agoric/vat-data to avoid circular dependencies.
-const makeExoUtils = VatData => {
-  const { defineDurableKind, makeKindHandle, watchPromise } = VatData;
-
-  const provideKindHandle = (baggage, kindName) =>
-    provide(baggage, `${kindName}_kindHandle`, () => makeKindHandle(kindName));
-
-  const emptyRecord = harden({});
-  const initEmpty = () => emptyRecord;
-
-  const defineDurableExoClass = (
-    kindHandle,
-    interfaceGuard,
-    init,
-    methods,
-    options,
-  ) =>
-    defineDurableKind(kindHandle, init, methods, {
-      ...options,
-      thisfulMethods: true,
-      interfaceGuard,
-    });
-
-  const prepareExoClass = (
-    baggage,
-    kindName,
-    interfaceGuard,
-    init,
-    methods,
-    options = undefined,
-  ) =>
-    defineDurableExoClass(
-      provideKindHandle(baggage, kindName),
-      interfaceGuard,
-      init,
-      methods,
-      options,
-    );
-
-  const prepareExo = (
-    baggage,
-    kindName,
-    interfaceGuard,
-    methods,
-    options = undefined,
-  ) => {
-    const makeSingleton = prepareExoClass(
-      baggage,
-      kindName,
-      interfaceGuard,
-      initEmpty,
-      methods,
-      options,
-    );
-    return provide(baggage, `the_${kindName}`, () => makeSingleton());
-  };
-
-  return {
-    defineDurableKind,
-    makeKindHandle,
-    watchPromise,
-
-    provideKindHandle,
-    defineDurableExoClass,
-    prepareExoClass,
-    prepareExo,
-  };
-};
-
 // cf. packages/SwingSet/test/vat-durable-promise-watcher.js
 const buildPromiseWatcherRootObject = (vatPowers, vatParameters, baggage) => {
   const { VatData } = vatPowers;

package/test/strict-test-env-upgrade.test.js

@@ -0,0 +1,94 @@
+/* global globalThis */
+// eslint-disable-next-line import/order
+import { annihilate, startLife } from '../tools/prepare-strict-test-env.js';
+
+import test from 'ava';
+
+import { makeUpgradeDisconnection } from '@agoric/internal/src/upgrade-api.js';
+import { makeExoUtils } from './exo-utils.js';
+
+test.serial('kind redefinition enforced', async t => {
+  annihilate();
+
+  const { prepareExoClass } = makeExoUtils(globalThis.VatData);
+
+  await startLife(async baggage => {
+    const makeTestExo = prepareExoClass(
+      baggage,
+      'TestExo',
+      undefined,
+      () => ({}),
+      {
+        foo() {
+          return 'bar';
+        },
+      },
+    );
+
+    baggage.init('testExo', makeTestExo());
+  });
+
+  await t.throwsAsync(
+    async () =>
+      startLife(async () => {
+        // Not redefining the kind here
+      }),
+    { message: 'defineDurableKind not called for tags: [TestExo]' },
+  );
+
+  await startLife(async baggage => {
+    prepareExoClass(baggage, 'TestExo', undefined, () => ({}), {
+      foo() {
+        return 'baz';
+      },
+    });
+
+    t.is(baggage.get('testExo').foo(), 'baz');
+  });
+});
+
+test.serial('decided promise rejected', async t => {
+  annihilate();
+
+  const { prepareExo } = makeExoUtils(globalThis.VatData);
+  const { watchPromise } = globalThis.VatData;
+
+  t.plan(1);
+
+  await startLife(async baggage => {
+    const watcher = prepareExo(
+      baggage,
+      'DurablePromiseTestWatcher',
+      undefined,
+      {
+        onFulfilled(value) {
+          t.fail(
+            `First incarnation watcher onFulfilled triggered with value ${value}`,
+          );
+        },
+        onRejected(reason) {
+          t.fail(
+            `First incarnation watcher onRejected triggered with reason ${reason}`,
+          );
+        },
+      },
+    );
+
+    const never = harden(new Promise(() => {}));
+
+    watchPromise(never, watcher);
+  });
+
+  await startLife(async baggage => {
+    prepareExo(baggage, 'DurablePromiseTestWatcher', undefined, {
+      onFulfilled(value) {
+        t.fail(
+          `Second incarnation watcher onFulfilled triggered with value ${value}`,
+        );
+      },
+      onRejected(reason) {
+        t.deepEqual(reason, makeUpgradeDisconnection('vat upgraded', 1));
+      },
+    });
+  });
+});

package/test/virtual-objects/virtualObjectManager.test.js

@@ -127,8 +127,8 @@ test('multifaceted virtual objects', t => {
 
   flushStateCache();
   t.deepEqual(log.splice(0), [
-    `get kindIDID => undefined`,
     `get idCounters => undefined`,
+    `get kindIDID => undefined`,
     `set kindIDID 1`,
     `set vom.vkind.2.descriptor {"kindID":"2","tag":"multithing"}`,
     `set vom.${kid}/1 ${multiThingVal('foo', 1)}`,
@@ -203,8 +203,8 @@ test('virtual object operations', t => {
   // t3-0: 'thing-3' 200 0
   const thing4 = makeThing('thing-4', 300); // [t4-0* t3-0* t2-0* t1-0*]
   // t4-0: 'thing-4' 300 0
-  t.is(log.shift(), `get kindIDID => undefined`);
   t.is(log.shift(), `get idCounters => undefined`);
+  t.is(log.shift(), `get kindIDID => undefined`);
   t.is(log.shift(), `set kindIDID 1`);
   t.is(log.shift(), `set vom.vkind.2.descriptor {"kindID":"2","tag":"thing"}`);
   t.is(log.shift(), `set vom.vkind.3.descriptor {"kindID":"3","tag":"zot"}`);
@@ -468,8 +468,8 @@ test('symbol named methods', t => {
   // t1-0: 'thing-1' 0 0
   const thing2 = makeThing('thing-2', 100); // [t1-0* t2-0*]
   // t2-0: 'thing-2' 100 0
-  t.is(log.shift(), `get kindIDID => undefined`);
   t.is(log.shift(), `get idCounters => undefined`);
+  t.is(log.shift(), `get kindIDID => undefined`);
   t.is(log.shift(), `set kindIDID 1`);
   t.is(
     log.shift(),
@@ -649,8 +649,8 @@ test('virtual object gc', t => {
     },
   });
 
-  t.is(log.shift(), `get kindIDID => undefined`);
   t.is(log.shift(), `get idCounters => undefined`);
+  t.is(log.shift(), `get kindIDID => undefined`);
   t.is(log.shift(), `set kindIDID 1`);
   const skit = [
     'storeKindIDTable',

package/tools/fakeVirtualObjectManager.js

@@ -23,6 +23,7 @@ export function makeFakeVirtualObjectManager(vrm, fakeStuff) {
     VirtualObjectAwareWeakSet,
     flushStateCache,
     canBeDurable,
+    insistAllDurableKindsReconnected,
   } = makeVirtualObjectManager(
     fakeStuff.syscall,
     vrm,
@@ -43,6 +44,7 @@ export function makeFakeVirtualObjectManager(vrm, fakeStuff) {
     defineDurableKindMulti,
     makeKindHandle,
     canBeDurable,
+    insistAllDurableKindsReconnected,
     VirtualObjectAwareWeakMap,
     VirtualObjectAwareWeakSet,
   };

package/tools/fakeVirtualSupport.js

@@ -28,12 +28,14 @@ class FakeFinalizationRegistry {
 }
 
 class FakeWeakRef {
+  #target;
+
   constructor(target) {
-    this.target = target;
+    this.#target = target;
   }
 
   deref() {
-    return this.target; // strong ref
+    return this.#target; // strong ref
   }
 }
 
@@ -41,6 +43,7 @@ export function makeFakeLiveSlotsStuff(options = {}) {
   let vrm;
   function setVrm(vrmToUse) {
     assert(!vrm, 'vrm already configured');
+    vrmToUse.initializeIDCounters();
     vrm = vrmToUse;
   }
 
@@ -174,6 +177,7 @@ export function makeFakeLiveSlotsStuff(options = {}) {
   // and the WeakRef may or may not contain the target value. Use
   // options={weak:true} to match that behavior, or the default weak:false to
   // keep strong references.
+  const WeakRefForSlot = weak ? RealWeakRef : FakeWeakRef;
   const valToSlot = new WeakMap();
   const slotToVal = new Map();
 
@@ -183,7 +187,7 @@ export function makeFakeLiveSlotsStuff(options = {}) {
 
   function getValForSlot(slot) {
     const d = slotToVal.get(slot);
-    return d && (weak ? d.deref() : d);
+    return d && d.deref();
   }
 
   function requiredValForSlot(slot) {
@@ -193,7 +197,7 @@ export function makeFakeLiveSlotsStuff(options = {}) {
   }
 
   function setValForSlot(slot, val) {
-    slotToVal.set(slot, weak ? new RealWeakRef(val) : val);
+    slotToVal.set(slot, new WeakRefForSlot(val));
   }
 
   function convertValToSlot(val) {
@@ -275,6 +279,7 @@ export function makeFakeLiveSlotsStuff(options = {}) {
   return {
     syscall,
     allocateExportID,
+    allocatePromiseID,
     allocateCollectionID,
     getSlotForVal,
     requiredValForSlot,
@@ -339,7 +344,7 @@ export function makeFakeWatchedPromiseManager(
  * @param {object} [options]
  * @param {number} [options.cacheSize]
  * @param {boolean} [options.relaxDurabilityRules]
- * @param {Map<any, any>} [options.fakeStore]
+ * @param {Map<string, string>} [options.fakeStore]
  * @param {WeakMapConstructor} [options.WeakMap]
  * @param {WeakSetConstructor} [options.WeakSet]
  * @param {boolean} [options.weak]

package/tools/prepare-strict-test-env.js

@@ -0,0 +1,121 @@
+/**
+ * Prepare Agoric SwingSet vat global strict environment for testing.
+ *
+ * Installs Hardened JS (and does lockdown), plus adds mocks for virtual objects
+ * and stores.
+ *
+ * Exports tools for simulating upgrades.
+ */
+
+import '@agoric/internal/src/install-ses-debug.js';
+
+// eslint-disable-next-line import/order
+import { reincarnate, flushIncarnation } from './setup-vat-data.js';
+
+import { makePromiseKit } from '@endo/promise-kit';
+import { Fail } from '@endo/errors';
+import { eventLoopIteration } from '@agoric/internal/src/testing-utils.js';
+import { makeUpgradeDisconnection } from '@agoric/internal/src/upgrade-api.js';
+
+export { flushIncarnation };
+export { eventLoopIteration as nextCrank };
+
+/**
+ * @import { ReincarnateOptions } from './setup-vat-data.js'
+ */
+
+/** @type {ReincarnateOptions} */
+let incarnation;
+let incarnationNumber = 0;
+
+/** @param {Omit<ReincarnateOptions, 'fakeVomKit' | 'fakeStore'>} [options] */
+export const annihilate = (options = {}) => {
+  // @ts-expect-error fakeStore and fakeVomKit don't exist on type, but drop them if they do at runtime
+  const { fakeStore: _fs, fakeVomKit: _fvk, ...opts } = options;
+  incarnation = reincarnate({ relaxDurabilityRules: false, ...opts });
+  incarnationNumber = 0;
+  return incarnation;
+};
+
+export const getBaggage = () => {
+  return incarnation.fakeVomKit.cm.provideBaggage();
+};
+
+/**
+ * @param {ReincarnateOptions} [fromIncarnation]
+ */
+export const nextLife = (fromIncarnation = incarnation) => {
+  incarnation = reincarnate(fromIncarnation);
+  incarnationNumber += 1;
+  return incarnation;
+};
+
+/**
+ * @template {(baggage: import('@agoric/swingset-liveslots').Baggage) => Promise<any> | any} B
+ * @param {B} build
+ * @param {(tools: Awaited<ReturnType<B>>) => Promise<void> | void} [run]
+ * @param {object} [options]
+ * @param {ReincarnateOptions} [options.fromIncarnation]
+ * @param {boolean} [options.cleanStart]
+ */
+export const startLife = async (
+  build,
+  run,
+  { fromIncarnation, cleanStart } = {},
+) => {
+  await eventLoopIteration();
+  if (cleanStart) annihilate();
+  const oldIncarnationNumber = incarnationNumber;
+  const oldIncarnation = incarnation;
+  const disconnectionObject = makeUpgradeDisconnection(
+    'vat upgraded',
+    oldIncarnationNumber,
+  );
+  const { fakeVomKit } = nextLife(fromIncarnation);
+  /** @type {Map<string, import('@endo/promise-kit').PromiseKit<any>>} */
+  const previouslyWatchedPromises = new Map();
+  let buildTools;
+  try {
+    buildTools = await build(getBaggage());
+    fakeVomKit.wpm.loadWatchedPromiseTable(vref => {
+      // See revivePromise in liveslots.js
+      const { getValForSlot, valToSlot, setValForSlot } = fakeVomKit.fakeStuff;
+      // Assume all promises were decided by the previous incarnation
+      !getValForSlot(vref) || Fail`Attempting to revive known promise ${vref}`;
+      const pk = makePromiseKit();
+      previouslyWatchedPromises.set(vref, pk);
+      const val = pk.promise;
+      valToSlot.set(val, vref);
+      setValForSlot(vref, val);
+      return val;
+    });
+
+    fakeVomKit.vom.insistAllDurableKindsReconnected();
+
+    await eventLoopIteration();
+    // End of start crank
+  } catch (err) {
+    // Rollback upgrade
+    incarnation = oldIncarnation;
+    incarnationNumber = oldIncarnationNumber;
+    throw err;
+  }
+
+  // Simulate a dispatch of previously decided promise rejections
+  // In real swingset this could happen after some deliveries
+  for (const { reject } of previouslyWatchedPromises.values()) {
+    reject(disconnectionObject);
+  }
+  await eventLoopIteration();
+  // End of resolution dispatch crank
+
+  if (run) {
+    await run(buildTools);
+    await eventLoopIteration();
+  }
+
+  return incarnation;
+};
+
+// Setup the initial incarnation
+annihilate();

package/tools/setup-vat-data.js

@@ -12,7 +12,9 @@ import { makeFakeVirtualStuff } from './fakeVirtualSupport.js';
 
 const { WeakMap, WeakSet } = globalThis;
 
-/** @type {ReturnType<makeFakeVirtualStuff>} */
+/** @typedef {ReturnType<typeof makeFakeVirtualStuff>} FakeVomKit */
+
+/** @type {FakeVomKit} */
 let fakeVomKit;
 
 globalThis.VatData = harden({
@@ -44,18 +46,43 @@ globalThis.VatData = harden({
 
 globalThis[PassStyleOfEndowmentSymbol] = passStyleOf;
 
-export const reincarnate = (options = {}) => {
-  const { fakeStore = new Map(), fakeVomKit: fvk } = options;
+/**
+ * @typedef {import("@agoric/internal").Simplify<
+ *   Omit<NonNullable<Parameters<typeof makeFakeVirtualStuff>[0]>, 'WeakMap' | 'WeakSet'> &
+ *   { fakeVomKit: FakeVomKit; fakeStore: Map<string, string> }
+ * >} ReincarnateOptions
+ */
 
-  if (options.fakeVomKit) {
+/**
+ *
+ * @param {Partial<ReincarnateOptions>} options
+ * @returns {Omit<ReincarnateOptions, 'fakeVomKit'>}
+ */
+export const flushIncarnation = (options = {}) => {
+  const { fakeVomKit: fvk = fakeVomKit, ...fakeStuffOptions } = options;
+
+  if (fvk) {
     fvk.vom.flushStateCache();
     fvk.cm.flushSchemaCache();
     fvk.vrm.flushIDCounters();
   }
 
+  // Clone previous fakeStore (if any) to avoid mutations from previous incarnation
+  const fakeStore = new Map(options.fakeStore);
+
+  return { ...fakeStuffOptions, fakeStore };
+};
+
+/**
+ *
+ * @param {Partial<ReincarnateOptions>} options
+ * @returns {ReincarnateOptions}
+ */
+export const reincarnate = (options = {}) => {
+  const clonedIncarnation = flushIncarnation(options);
+
   fakeVomKit = makeFakeVirtualStuff({
-    ...options,
-    fakeStore,
+    ...clonedIncarnation,
     WeakMap,
     WeakSet,
   });
@@ -65,5 +92,5 @@ export const reincarnate = (options = {}) => {
   // @ts-expect-error ditto
   globalThis.WeakSet = fakeVomKit.vom.VirtualObjectAwareWeakSet;
 
-  return { ...options, fakeStore, fakeVomKit };
+  return { ...clonedIncarnation, fakeVomKit };
 };