@agoric/swingset-liveslots 0.10.3-u16.0 → 0.10.3-u17.0

package/test/vat-environment.test.js

@@ -0,0 +1,65 @@
+// @ts-nocheck
+import '@endo/init/debug.js';
+import test from 'ava';
+import { Far } from '@endo/marshal';
+import { kser } from '@agoric/kmarshal';
+import { passStyleOf } from '@endo/pass-style';
+import { PassStyleOfEndowmentSymbol } from '@endo/pass-style/endow.js';
+import { makeLiveSlots } from '../src/index.js';
+import { makeStartVat } from './util.js';
+import { buildSyscall } from './liveslots-helpers.js';
+import { makeMockGC } from './mock-gc.js';
+
+test('vat globals', async t => {
+  const { syscall } = buildSyscall();
+  const gcTools = makeMockGC();
+  const buildRootObject = () => Far('root', {});
+  let called = 0;
+  let vatGlobals;
+  let inescapableGlobalProperties;
+  const vatNS = harden({ buildRootObject });
+  // buildVatNamespace
+  const bVN = async (vG, iGP) => {
+    called += 1;
+    vatGlobals = vG;
+    inescapableGlobalProperties = iGP;
+    return vatNS;
+  };
+
+  const ls = makeLiveSlots(syscall, 'vatA', {}, {}, gcTools, undefined, bVN);
+  t.is(called, 0); // not called yet
+  await ls.dispatch(makeStartVat(kser()));
+  t.is(called, 1);
+  t.truthy(vatGlobals);
+
+  // 'harden' is provided by SES (installed by the lockdown bundle),
+  // not liveslots
+  t.is(typeof vatGlobals.harden, 'undefined');
+
+  // but liveslots provides VatData
+  t.is(typeof vatGlobals.VatData, 'object');
+  t.is(typeof vatGlobals.VatData, 'object');
+  t.is(typeof vatGlobals.VatData.defineKind, 'function');
+  t.is(typeof vatGlobals.VatData.defineKindMulti, 'function');
+  t.is(typeof vatGlobals.VatData.defineDurableKind, 'function');
+  t.is(typeof vatGlobals.VatData.defineDurableKindMulti, 'function');
+  t.is(typeof vatGlobals.VatData.makeKindHandle, 'function');
+  t.is(typeof vatGlobals.VatData.canBeDurable, 'function');
+  t.is(typeof vatGlobals.VatData.providePromiseWatcher, 'function');
+  t.is(typeof vatGlobals.VatData.watchPromise, 'function');
+  t.is(typeof vatGlobals.VatData.makeScalarBigMapStore, 'function');
+  t.is(typeof vatGlobals.VatData.makeScalarBigWeakMapStore, 'function');
+  t.is(typeof vatGlobals.VatData.makeScalarBigSetStore, 'function');
+  t.is(typeof vatGlobals.VatData.makeScalarBigWeakSetStore, 'function');
+
+  t.is(typeof inescapableGlobalProperties.WeakMap, 'function');
+  t.not(inescapableGlobalProperties.WeakMap, WeakMap);
+  t.is(typeof inescapableGlobalProperties.WeakSet, 'function');
+  t.not(inescapableGlobalProperties.WeakSet, WeakSet);
+  t.is(
+    typeof inescapableGlobalProperties[PassStyleOfEndowmentSymbol],
+    'function',
+  );
+  // this is the passStyleOf created by liveslots, with a real WeakMap
+  t.is(inescapableGlobalProperties[PassStyleOfEndowmentSymbol], passStyleOf);
+});

package/test/vat-util.js

@@ -1,7 +1,7 @@
 // this file is imported by some test vats, so don't import any non-pure
 // modules
 
-import { Fail } from '@agoric/assert';
+import { Fail } from '@endo/errors';
 import { kser, kunser } from '@agoric/kmarshal';
 
 export function extractMessage(vatDeliverObject) {

package/test/virtual-objects/rep-tostring.test.js

@@ -5,12 +5,11 @@ import './set-debug-label-instances.js';
 import { passStyleOf } from '@endo/far';
 
 // this samples it
+import { q } from '@endo/errors';
 import { makeFakeVirtualStuff } from '../../tools/fakeVirtualSupport.js';
 // all tests in this file will be run with DEBUG='label-instances'
 import { parseVatSlot } from '../../src/parseVatSlots.js';
 
-const { quote: q } = assert;
-
 const init = () => ({});
 const behavior = {};
 const facets = { foo: {}, bar: {} };

package/test/vpid-liveslots.test.js

@@ -1,10 +1,10 @@
 // @ts-nocheck
 import test from 'ava';
 
+import { Fail } from '@endo/errors';
 import { E } from '@endo/eventual-send';
 import { makePromiseKit } from '@endo/promise-kit';
 import { Far } from '@endo/marshal';
-import { Fail } from '@agoric/assert';
 import { kser, kslot } from '@agoric/kmarshal';
 import { buildSyscall, makeDispatch } from './liveslots-helpers.js';
 import { makeMessage, makeResolve, makeReject } from './util.js';
@@ -898,3 +898,104 @@ test('inter-vat circular promise references', async t => {
   // });
   // t.deepEqual(log, []);
 });
+
+test('accept previously allocated promise', async t => {
+  function build(vatPowers, vatParameters) {
+    const { target } = vatParameters;
+    return Far('root', {
+      call() {
+        const promise = E(target).foo();
+        // wrap to avoid adoption
+        return { promise };
+      },
+      async waitFor(promise2) {
+        // if we're in the same incarnation as the `E(target).foo()`, this
+        // `promise2` will be the same JS Promise as the `promise` above
+        const v = await promise2;
+        return v;
+      },
+    });
+  }
+
+  let log;
+  let syscall;
+  let dispatch;
+
+  const kvStore = new Map();
+  ({ log, syscall } = buildSyscall({ kvStore }));
+
+  const target = 'o-1';
+  ({ dispatch } = await makeDispatch(
+    syscall,
+    build,
+    'reimport-promise',
+    {},
+    { target: kslot(target) },
+  ));
+  log.length = 0; // assume pre-build vatstore operations are correct
+
+  const root = 'o+0';
+  const callResultP = 'p-1';
+  const waitForResultP = 'p-2';
+  const expectedP1 = 'p+5';
+
+  await dispatch(makeMessage(root, 'call', [], callResultP));
+
+  // The vat should send 'foo', subscribe to the result promise, and resolve with that promise
+  t.deepEqual(log.splice(0, 3), [
+    {
+      type: 'send',
+      targetSlot: target,
+      methargs: kser(['foo', []]),
+      resultSlot: expectedP1,
+    },
+    { type: 'subscribe', target: expectedP1 },
+    {
+      type: 'resolve',
+      resolutions: [[callResultP, false, kser({ promise: kslot(expectedP1) })]],
+    },
+  ]);
+  matchIDCounterSet(t, log);
+  t.deepEqual(log, []);
+
+  // snapshot the store at this point
+  const clonedStore = new Map(kvStore);
+
+  const verifyPromiseReImport = async shouldSubscribe => {
+    await dispatch(
+      makeMessage(root, 'waitFor', [kslot(expectedP1)], waitForResultP),
+    );
+
+    // The vat will only subscribe if it was upgraded; if the vat still
+    // remembers it, receiving the vref will merely look it up in slotToVal and
+    // not create a new Promise (and trigger a subscribe)
+    if (shouldSubscribe) {
+      t.deepEqual(log.shift(), { type: 'subscribe', target: expectedP1 });
+    }
+
+    // waitFor will suspend until promise is resolved
+    t.deepEqual(log, []);
+
+    // Resolution propagates the value to the waitFor result
+    await dispatch(makeResolve(expectedP1, kser('success')));
+    t.deepEqual(log.shift(), {
+      type: 'resolve',
+      resolutions: [[waitForResultP, false, kser('success')]],
+    });
+    t.deepEqual(log, []);
+  };
+
+  await verifyPromiseReImport(false);
+  ({ log, syscall } = buildSyscall({ kvStore: clonedStore }));
+  ({ dispatch } = await makeDispatch(
+    syscall,
+    build,
+    'reimport-promise-v2',
+    {},
+    {},
+  ));
+  log.length = 0;
+
+  // verify this works the same in the restarted vat
+  await verifyPromiseReImport(true);
+});

package/test/weakset-dropped-remotable.test.js

@@ -0,0 +1,50 @@
+import test from 'ava';
+import { Far } from '@endo/marshal';
+import { kser, kslot } from '@agoric/kmarshal';
+import { makeLiveSlots } from '../src/liveslots.js';
+import { buildSyscall } from './liveslots-helpers.js';
+import { makeStartVat, makeMessage, makeBringOutYourDead } from './util.js';
+import { makeMockGC } from './mock-gc.js';
+
+// Test for https://github.com/Agoric/agoric-sdk/issues/9956
+
+test('delete remotable key from weakset', async t => {
+  const { syscall, log } = buildSyscall();
+  const gcTools = makeMockGC();
+  const rem = Far('remotable', {});
+
+  function buildRootObject(vatPowers) {
+    const { VatData } = vatPowers;
+    const { makeScalarBigWeakMapStore } = VatData;
+    const wms = makeScalarBigWeakMapStore();
+    return Far('root', {
+      store: p => {
+        wms.init(rem, p);
+        gcTools.kill(p);
+      },
+    });
+  }
+
+  const makeNS = () => ({ buildRootObject });
+  const ls = makeLiveSlots(syscall, 'vatA', {}, {}, gcTools, undefined, makeNS);
+  const { dispatch } = ls;
+  await dispatch(makeStartVat(kser()));
+
+  await dispatch(makeMessage('o+0', 'store', [kslot('o-1')]));
+
+  // pretend the Remotable was dropped from RAM
+  log.length = 0;
+  gcTools.kill(rem);
+  gcTools.flushAllFRs();
+  await dispatch(makeBringOutYourDead());
+
+  // that ought to emit a drop and retire for the presence
+  const gcCalls = log.filter(
+    l => l.type === 'dropImports' || l.type === 'retireImports',
+  );
+  t.deepEqual(gcCalls, [
+    { type: 'dropImports', slots: ['o-1'] },
+    { type: 'retireImports', slots: ['o-1'] },
+  ]);
+  log.length = 0;
+});

package/tools/fakeVirtualSupport.js

@@ -1,7 +1,7 @@
 /* global globalThis */
 /* eslint-disable max-classes-per-file */
+import { assert, Fail } from '@endo/errors';
 import { makeMarshal } from '@endo/marshal';
-import { assert } from '@agoric/assert';
 import { isPromise } from '@endo/promise-kit';
 
 import { parseVatSlot } from '../src/parseVatSlots.js';
@@ -10,8 +10,6 @@ import { makeWatchedPromiseManager } from '../src/watchedPromises.js';
 import { makeFakeVirtualObjectManager } from './fakeVirtualObjectManager.js';
 import { makeFakeCollectionManager } from './fakeCollectionManager.js';
 
-const { Fail } = assert;
-
 const {
   WeakRef: RealWeakRef,
   WeakMap: RealWeakMap,

package/tools/setup-vat-data.js

@@ -1,8 +1,13 @@
 // @ts-check
 /* global globalThis */
-// This file produces the globalThis.VatData property outside of a running
-// SwingSet so that it can be used by '@agoric/vat-data' (which only *consumes*
-// `globalThis.VatData`) in code under test.
+
+// This file produces the globalThis.VatData property outside of a
+// running SwingSet so that it can be used by '@agoric/vat-data'
+// (which only *consumes* `globalThis.VatData`) in code under test. It
+// also populates the passStyleOf symbol-named property.
+
+import { passStyleOf } from '@endo/pass-style';
+import { PassStyleOfEndowmentSymbol } from '@endo/pass-style/endow.js';
 import { makeFakeVirtualStuff } from './fakeVirtualSupport.js';
 
 const { WeakMap, WeakSet } = globalThis;
@@ -37,6 +42,8 @@ globalThis.VatData = harden({
     fakeVomKit.cm.makeScalarBigWeakSetStore(...args),
 });
 
+globalThis[PassStyleOfEndowmentSymbol] = passStyleOf;
+
 export const reincarnate = (options = {}) => {
   const { fakeStore = new Map(), fakeVomKit: fvk } = options;