@agoric/swingset-vat 0.32.3-dev-02c06c4.0 → 0.32.3-dev-fd68b6a.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/swingset-vat",
-  "version": "0.32.3-dev-02c06c4.0+02c06c4",
+  "version": "0.32.3-dev-fd68b6a.0+fd68b6a",
   "description": "Vat/Container Launcher",
   "type": "module",
   "main": "src/index.js",
@@ -27,15 +27,15 @@
     "@types/yargs-parser": "^21.0.0"
   },
   "dependencies": {
-    "@agoric/internal": "0.3.3-dev-02c06c4.0+02c06c4",
-    "@agoric/kmarshal": "0.1.1-dev-02c06c4.0+02c06c4",
-    "@agoric/store": "0.9.3-dev-02c06c4.0+02c06c4",
-    "@agoric/swing-store": "0.9.2-dev-02c06c4.0+02c06c4",
-    "@agoric/swingset-liveslots": "0.10.3-dev-02c06c4.0+02c06c4",
-    "@agoric/swingset-xsnap-supervisor": "0.10.3-dev-02c06c4.0+02c06c4",
-    "@agoric/time": "0.3.3-dev-02c06c4.0+02c06c4",
-    "@agoric/vat-data": "0.5.3-dev-02c06c4.0+02c06c4",
-    "@agoric/xsnap-lockdown": "0.14.1-dev-02c06c4.0+02c06c4",
+    "@agoric/internal": "0.3.3-dev-fd68b6a.0+fd68b6a",
+    "@agoric/kmarshal": "0.1.1-dev-fd68b6a.0+fd68b6a",
+    "@agoric/store": "0.9.3-dev-fd68b6a.0+fd68b6a",
+    "@agoric/swing-store": "0.9.2-dev-fd68b6a.0+fd68b6a",
+    "@agoric/swingset-liveslots": "0.10.3-dev-fd68b6a.0+fd68b6a",
+    "@agoric/swingset-xsnap-supervisor": "0.10.3-dev-fd68b6a.0+fd68b6a",
+    "@agoric/time": "0.3.3-dev-fd68b6a.0+fd68b6a",
+    "@agoric/vat-data": "0.5.3-dev-fd68b6a.0+fd68b6a",
+    "@agoric/xsnap-lockdown": "0.14.1-dev-fd68b6a.0+fd68b6a",
     "@endo/base64": "^1.0.8",
     "@endo/bundle-source": "^3.4.2",
     "@endo/captp": "^4.4.2",
@@ -103,5 +103,5 @@
   "typeCoverage": {
     "atLeast": 76.19
   },
-  "gitHead": "02c06c489677233c0daa112284d16c314aff97c6"
+  "gitHead": "fd68b6ac1620d3ac9b6e98eeee7a507c3ccb3d79"
 }

package/src/controller/initializeSwingset.js

@@ -2,7 +2,7 @@
 import fs from 'fs';
 import path from 'path';
 
-import { assert, Fail } from '@endo/errors';
+import { assert, b, Fail } from '@endo/errors';
 import { makeTracer } from '@agoric/internal';
 import { mustMatch } from '@agoric/store';
 import bundleSource from '@endo/bundle-source';
@@ -86,16 +86,6 @@ export async function buildKernelBundles() {
   return harden({ kernel: kernelBundle, ...vdBundles });
 }
 
-function byName(a, b) {
-  if (a.name < b.name) {
-    return -1;
-  }
-  if (a.name > b.name) {
-    return 1;
-  }
-  return 0;
-}
-
 /**
  * Scan a directory for files defining the vats to bootstrap for a swingset, and
  * produce a swingset config object for what was found there.  Looks for files
@@ -126,18 +116,18 @@ export function loadBasedir(basedir, options = {}) {
   const { includeDevDependencies = false, bundleFormat = undefined } = options;
   /** @type { SwingSetConfigDescriptor } */
   const vats = {};
-  const subs = fs.readdirSync(basedir, { withFileTypes: true });
-  subs.sort(byName);
-  for (const dirent of subs) {
-    if (
-      dirent.name.startsWith('vat-') &&
-      dirent.name.endsWith('.js') &&
-      dirent.isFile()
-    ) {
-      const name = dirent.name.slice('vat-'.length, -'.js'.length);
-      const vatSourcePath = path.resolve(basedir, dirent.name);
-      vats[name] = { sourceSpec: vatSourcePath, parameters: {} };
-    }
+  const rVatName = /^vat-(.*)\.js$/s;
+  const files = fs.readdirSync(basedir, { withFileTypes: true });
+  const vatFiles = files.flatMap(dirent => {
+    const file = dirent.name;
+    const m = rVatName.exec(file);
+    return m && dirent.isFile() ? [{ file, label: m[1] }] : [];
+  });
+  // eslint-disable-next-line no-shadow,no-nested-ternary
+  vatFiles.sort((a, b) => (a.label < b.label ? -1 : a.label > b.label ? 1 : 0));
+  for (const { file, label } of vatFiles) {
+    const vatSourcePath = path.resolve(basedir, file);
+    vats[label] = { sourceSpec: vatSourcePath, parameters: {} };
   }
   /** @type {string | void} */
   let bootstrapPath = path.resolve(basedir, 'bootstrap.js');
@@ -185,37 +175,42 @@ async function resolveSpecFromConfig(referrer, specPath) {
 }
 
 /**
- * For each entry in a config descriptor (i.e, `vats`, `bundles`, etc), convert
- * it to normal form: resolve each pathname to a context-insensitive absolute
- * path and make sure it has a `parameters` property if it's supposed to.
+ * Convert each entry in a config descriptor group (`vats`/`bundles`/etc.) to
+ * normal form: resolve each pathname to a context-insensitive absolute path and
+ * run any other appropriate fixup.
  *
- * @param {SwingSetConfigDescriptor | void} desc  The config descriptor to be normalized.
- * @param {string} referrer  The pathname of the file or directory in which the
- * config file was found
- * @param {boolean} expectParameters `true` if the entries should have parameters (for
- *    example, `true` for `vats` but `false` for bundles).
+ * @param {SwingSetConfig} config
+ * @param {'vats' | 'bundles' | 'devices'} groupName
+ * @param {string | undefined} configPath of the containing config file
+ * @param {string} referrer URL
+ * @param {(entry: SwingSetConfigProperties, name?: string) => void} [fixupEntry]
+ *   A function to call on each entry to e.g. add defaults for missing fields
+ *   such as vat `parameters`.
  */
-async function normalizeConfigDescriptor(desc, referrer, expectParameters) {
-  const normalizeSpec = async (entry, key) => {
-    return resolveSpecFromConfig(referrer, entry[key]).then(spec => {
-      fs.existsSync(spec) ||
-        Fail`spec for ${entry[key]} does not exist: ${spec}`;
-      entry[key] = spec;
-    });
+async function normalizeConfigDescriptor(
+  config,
+  groupName,
+  configPath,
+  referrer,
+  fixupEntry,
+) {
+  const normalizeSpec = async (entry, specKey, name) => {
+    const sourcePath = await resolveSpecFromConfig(referrer, entry[specKey]);
+    fs.existsSync(sourcePath) ||
+      Fail`${sourcePath} for ${b(groupName)}[${name}].${b(specKey)} in ${configPath} config file does not exist`;
+    entry[specKey] = sourcePath;
   };
 
   const jobs = [];
+  const desc = config[groupName];
   if (desc) {
-    for (const name of Object.keys(desc)) {
-      const entry = desc[name];
+    for (const [name, entry] of Object.entries(desc)) {
+      fixupEntry?.(entry, name);
       if ('sourceSpec' in entry) {
-        jobs.push(normalizeSpec(entry, 'sourceSpec'));
+        jobs.push(normalizeSpec(entry, 'sourceSpec', name));
       }
       if ('bundleSpec' in entry) {
-        jobs.push(normalizeSpec(entry, 'bundleSpec'));
-      }
-      if (expectParameters && !entry.parameters) {
-        entry.parameters = {};
+        jobs.push(normalizeSpec(entry, 'bundleSpec', name));
       }
     }
   }
@@ -223,27 +218,41 @@ async function normalizeConfigDescriptor(desc, referrer, expectParameters) {
 }
 
 /**
- * Read and parse a swingset config file and return it in normalized form.
- *
- * @param {string} configPath  Path to the config file to be processed
- *
- * @returns {Promise<SwingSetConfig | null>} the contained config object, in normalized form, or null if the
- *    requested config file did not exist.
+ * @param {SwingSetConfig} config
+ * @param {string} [configPath]
+ * @returns {Promise<void>}
+ * @throws {Error} if the config is invalid
+ */
+export async function normalizeConfig(config, configPath) {
+  const base = `file://${process.cwd()}/`;
+  const referrer = configPath
+    ? new URL(configPath, base).href
+    : new URL(base).href;
+  const fixupVat = vat => (vat.parameters ||= {});
+  await Promise.all([
+    normalizeConfigDescriptor(config, 'vats', configPath, referrer, fixupVat),
+    normalizeConfigDescriptor(config, 'bundles', configPath, referrer),
+    // TODO: represent devices
+    // normalizeConfigDescriptor(config, 'devices', configPath, referrer),
+  ]);
+  config.bootstrap ||
+    Fail`no designated bootstrap vat in ${configPath} config file`;
+  (config.vats && config.vats[/** @type {string} */ (config.bootstrap)]) ||
+    Fail`bootstrap vat ${config.bootstrap} not found in ${configPath} config file`;
+}
+
+/**
+ * Read and normalize a swingset config file.
  *
- * @throws {Error} if the file existed but was inaccessible, malformed, or otherwise
- *    invalid.
+ * @param {string} configPath
+ * @returns {Promise<SwingSetConfig | null>} the normalized config,
+ *   or null if the file did not exist
  */
 export async function loadSwingsetConfigFile(configPath) {
   await null;
   try {
     const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    const referrer = new URL(configPath, `file://${process.cwd()}/`).toString();
-    await normalizeConfigDescriptor(config.vats, referrer, true);
-    await normalizeConfigDescriptor(config.bundles, referrer, false);
-    // await normalizeConfigDescriptor(config.devices, referrer, true); // TODO: represent devices
-    config.bootstrap || Fail`no designated bootstrap vat in ${configPath}`;
-    (config.vats && config.vats[config.bootstrap]) ||
-      Fail`bootstrap vat ${config.bootstrap} not found in ${configPath}`;
+    await normalizeConfig(config, configPath);
     return config;
   } catch (e) {
     console.error(`failed to load ${configPath}`);

package/src/index.js

@@ -8,6 +8,7 @@ export {
   buildKernelBundles,
   loadBasedir,
   loadSwingsetConfigFile,
+  normalizeConfig,
 } from './controller/initializeSwingset.js';
 export { upgradeSwingset } from './controller/upgradeSwingset.js';
 export {

package/src/kernel/state/kernelKeeper.js

@@ -43,6 +43,7 @@ const enableKernelGC = true;
  * @typedef { import('../../types-external.js').SnapStore } SnapStore
  * @typedef { import('../../types-external.js').TranscriptStore } TranscriptStore
  * @typedef { import('../../types-external.js').VatKeeper } VatKeeper
+ * @typedef { Pick<VatKeeper, 'deleteCListEntry' | 'deleteSnapshots' | 'deleteTranscripts'> } VatUndertaker
  * @typedef { import('../../types-internal.js').InternalKernelOptions } InternalKernelOptions
  * @typedef { import('../../types-internal.js').ReapDirtThreshold } ReapDirtThreshold
  * @import {PromiseRecord} from '../../types-internal.js';
@@ -422,6 +423,8 @@ export default function makeKernelKeeper(
   const ephemeral = harden({
     /** @type { Map<string, VatKeeper> } */
     vatKeepers: new Map(),
+    /** @type { Map<string, VatUndertaker> } */
+    vatUndertakers: new Map(),
     deviceKeepers: new Map(), // deviceID -> deviceKeeper
   });
 
@@ -1044,7 +1047,7 @@ export default function makeKernelKeeper(
     // first or vref first), and delete the other one in the same
     // call, so we don't wind up with half an entry.
 
-    const vatKeeper = provideVatKeeper(vatID);
+    const undertaker = provideVatUndertaker(vatID);
     const clistPrefix = `${vatID}.c.`;
     const exportPrefix = `${clistPrefix}o+`;
     const importPrefix = `${clistPrefix}o-`;
@@ -1092,7 +1095,7 @@ export default function makeKernelKeeper(
       // drop+retire
       const kref = kvStore.get(k) || Fail`getNextKey ensures get`;
       const vref = stripPrefix(clistPrefix, k);
-      vatKeeper.deleteCListEntry(kref, vref);
+      undertaker.deleteCListEntry(kref, vref);
       // that will also delete both db keys
       work.imports += 1;
       remaining -= 1;
@@ -1109,7 +1112,7 @@ export default function makeKernelKeeper(
     for (const k of enumeratePrefixedKeys(kvStore, promisePrefix)) {
       const kref = kvStore.get(k) || Fail`getNextKey ensures get`;
       const vref = stripPrefix(clistPrefix, k);
-      vatKeeper.deleteCListEntry(kref, vref);
+      undertaker.deleteCListEntry(kref, vref);
       // that will also delete both db keys
       work.promises += 1;
       remaining -= 1;
@@ -1131,7 +1134,7 @@ export default function makeKernelKeeper(
 
     // this will internally loop through 'budget' deletions
     remaining = budget.snapshots ?? budget.default;
-    const dsc = vatKeeper.deleteSnapshots(remaining);
+    const dsc = undertaker.deleteSnapshots(remaining);
     work.snapshots += dsc.cleanups;
     remaining -= dsc.cleanups;
     if (remaining <= 0) {
@@ -1140,7 +1143,7 @@ export default function makeKernelKeeper(
 
     // same
     remaining = budget.transcripts ?? budget.default;
-    const dts = vatKeeper.deleteTranscripts(remaining);
+    const dts = undertaker.deleteTranscripts(remaining);
     work.transcripts += dts.cleanups;
     remaining -= dts.cleanups;
     // last task, so increment cleanups, but dc.done is authoritative
@@ -1697,6 +1700,26 @@ export default function makeKernelKeeper(
     initializeVatState(kvStore, transcriptStore, vatID, source, options);
   }
 
+  /** @type {import('./vatKeeper.js').VatKeeperPowers} */
+  const vatKeeperPowers = {
+    transcriptStore,
+    kernelSlog,
+    addKernelObject,
+    addKernelPromiseForVat,
+    kernelObjectExists,
+    incrementRefCount,
+    decrementRefCount,
+    getObjectRefCount,
+    setObjectRefCount,
+    getReachableAndVatSlot,
+    addMaybeFreeKref,
+    incStat,
+    decStat,
+    getCrankNumber,
+    scheduleReap,
+    snapStore,
+  };
+
   function provideVatKeeper(vatID) {
     insistVatID(vatID);
     const found = ephemeral.vatKeepers.get(vatID);
@@ -1704,30 +1727,36 @@ export default function makeKernelKeeper(
       return found;
     }
     assert(kvStore.has(`${vatID}.o.nextID`), `${vatID} was not initialized`);
-    const vk = makeVatKeeper(
-      kvStore,
-      transcriptStore,
-      kernelSlog,
-      vatID,
-      addKernelObject,
-      addKernelPromiseForVat,
-      kernelObjectExists,
-      incrementRefCount,
-      decrementRefCount,
-      getObjectRefCount,
-      setObjectRefCount,
-      getReachableAndVatSlot,
-      addMaybeFreeKref,
-      incStat,
-      decStat,
-      getCrankNumber,
-      scheduleReap,
-      snapStore,
-    );
+    const vk = makeVatKeeper(vatID, kvStore, vatKeeperPowers);
     ephemeral.vatKeepers.set(vatID, vk);
     return vk;
   }
 
+  /**
+   * Produce an attenuated vatKeeper for slow vat termination (and that
+   * therefore does not insist on liveness, unlike provideVatKeeper).
+   *
+   * @param {string} vatID
+   */
+  function provideVatUndertaker(vatID) {
+    insistVatID(vatID);
+    const found = ephemeral.vatUndertakers.get(vatID);
+    if (found !== undefined) {
+      return found;
+    }
+    const { deleteCListEntry, deleteSnapshots, deleteTranscripts } =
+      ephemeral.vatKeepers.get(vatID) ||
+      makeVatKeeper(vatID, kvStore, vatKeeperPowers);
+    /** @type {VatUndertaker} */
+    const undertaker = harden({
+      deleteCListEntry,
+      deleteSnapshots,
+      deleteTranscripts,
+    });
+    ephemeral.vatUndertakers.set(vatID, undertaker);
+    return undertaker;
+  }
+
   function vatIsAlive(vatID) {
     insistVatID(vatID);
     return kvStore.has(`${vatID}.o.nextID`) && !terminatedVats.includes(vatID);

package/src/kernel/state/vatKeeper.js

@@ -84,49 +84,53 @@ export function initializeVatState(
 }
 
 /**
- * Produce a vat keeper for a vat.
+ * @typedef {object} VatKeeperPowers
+ * @property {TranscriptStore} transcriptStore  Accompanying transcript store, for the transcripts
+ * @property {*} kernelSlog
+ * @property {*} addKernelObject  Kernel function to add a new object to the kernel's mapping tables.
+ * @property {*} addKernelPromiseForVat  Kernel function to add a new promise to the kernel's mapping tables.
+ * @property {(kernelSlot: string) => boolean} kernelObjectExists
+ * @property {*} incrementRefCount
+ * @property {*} decrementRefCount
+ * @property {(kernelSlot: string) => {reachable: number, recognizable: number}} getObjectRefCount
+ * @property {(kernelSlot: string, o: { reachable: number, recognizable: number }) => void} setObjectRefCount
+ * @property {(vatID: string, kernelSlot: string) => {isReachable: boolean, vatSlot: string}} getReachableAndVatSlot
+ * @property {(kernelSlot: string) => void} addMaybeFreeKref
+ * @property {*} incStat
+ * @property {*} decStat
+ * @property {*} getCrankNumber
+ * @property {*} scheduleReap
+ * @property {SnapStore} snapStore
+ */
+
+/**
+ * Produce a "vat keeper" for the kernel state of a vat.
  *
- * @param {KVStore} kvStore  The keyValue store in which the persistent state will be kept
- * @param {TranscriptStore} transcriptStore  Accompanying transcript store, for the transcripts
- * @param {*} kernelSlog
  * @param {string} vatID  The vat ID string of the vat in question
- * @param {*} addKernelObject  Kernel function to add a new object to the kernel's
- * mapping tables.
- * @param {*} addKernelPromiseForVat  Kernel function to add a new promise to the
- * kernel's mapping tables.
- * @param {(kernelSlot: string) => boolean} kernelObjectExists
- * @param {*} incrementRefCount
- * @param {*} decrementRefCount
- * @param {(kernelSlot: string) => {reachable: number, recognizable: number}} getObjectRefCount
- * @param {(kernelSlot: string, o: { reachable: number, recognizable: number }) => void} setObjectRefCount
- * @param {(vatID: string, kernelSlot: string) => {isReachable: boolean, vatSlot: string}} getReachableAndVatSlot
- * @param {(kernelSlot: string) => void} addMaybeFreeKref
- * @param {*} incStat
- * @param {*} decStat
- * @param {*} getCrankNumber
- * @param {*} scheduleReap
- * @param {SnapStore} [snapStore]
- * returns an object to hold and access the kernel's state for the given vat
+ * @param {KVStore} kvStore  The keyValue store in which the persistent state will be kept
+ * @param {VatKeeperPowers} powers
  */
 export function makeVatKeeper(
-  kvStore,
-  transcriptStore,
-  kernelSlog,
   vatID,
-  addKernelObject,
-  addKernelPromiseForVat,
-  kernelObjectExists,
-  incrementRefCount,
-  decrementRefCount,
-  getObjectRefCount,
-  setObjectRefCount,
-  getReachableAndVatSlot,
-  addMaybeFreeKref,
-  incStat,
-  decStat,
-  getCrankNumber,
-  scheduleReap,
-  snapStore = undefined,
+  kvStore,
+  {
+    transcriptStore,
+    kernelSlog,
+    addKernelObject,
+    addKernelPromiseForVat,
+    kernelObjectExists,
+    incrementRefCount,
+    decrementRefCount,
+    getObjectRefCount,
+    setObjectRefCount,
+    getReachableAndVatSlot,
+    addMaybeFreeKref,
+    incStat,
+    decStat,
+    getCrankNumber,
+    scheduleReap,
+    snapStore,
+  },
 ) {
   insistVatID(vatID);
 

package/tools/bootstrap-relay.js

@@ -1,3 +1,12 @@
+/**
+ * @file Source code for a bootstrap vat that runs blockchain behaviors (such as
+ *   bridge vat integration) and exposes reflective methods for use in testing.
+ *
+ * TODO: Build from ./vat-puppet.js makeReflectionMethods
+ * and share code with packages/vats/tools/vat-reflective-chain-bootstrap.js
+ * (which basically extends this for better [mock] blockchain integration).
+ */
+
 import { Fail, q } from '@endo/errors';
 import { objectMap } from '@agoric/internal';
 import { Far, E } from '@endo/far';

package/tools/vat-puppet.js

@@ -0,0 +1,111 @@
+/**
+ * @file Source code for a vat that exposes reflective methods for use in
+ *   testing.
+ */
+
+import { Fail, q } from '@endo/errors';
+import { Far, E } from '@endo/far';
+import { makePromiseKit } from '@endo/promise-kit';
+import { objectMap } from '@agoric/internal';
+
+/**
+ * @callback Die
+ * @param {unknown} completion
+ * @param {[target: unknown, method: string, ...args: unknown[]]} [finalSend]
+ */
+
+/**
+ * @typedef {Array<[name: string, ...args: unknown[]]>} CallLog
+ */
+
+/**
+ * @param {import('@agoric/swingset-vat').VatPowers} vatPowers
+ * @param {import('@agoric/vat-data').Baggage} baggage
+ */
+export const makeReflectionMethods = (vatPowers, baggage) => {
+  let baggageHoldCount = 0;
+  /** @type {Map<object, CallLog>} */
+  const callLogsByRemotable = new Map();
+  const heldInHeap = [];
+  const send = (target, method, ...args) => E(target)[method](...args);
+  const makeSpy = (value, name, callLog) => {
+    const spyName = `get ${name}`;
+    const spy = {
+      [spyName](...args) {
+        callLog.push([name, ...args]);
+        return value;
+      },
+    }[spyName];
+    return spy;
+  };
+
+  return {
+    /** @type {Die} */
+    dieHappy: (completion, finalSend) => {
+      vatPowers.exitVat(completion);
+      if (finalSend) send(...finalSend);
+    },
+
+    /** @type {Die} */
+    dieSad: (reason, finalSend) => {
+      vatPowers.exitVatWithFailure(/** @type {Error} */ (reason));
+      if (finalSend) send(...finalSend);
+    },
+
+    holdInBaggage: (...values) => {
+      for (const value of values) {
+        baggage.init(`held-${baggageHoldCount}`, value);
+        baggageHoldCount += 1;
+      }
+      return baggageHoldCount;
+    },
+
+    holdInHeap: (...values) => heldInHeap.push(...values),
+
+    makePromiseKit: () => {
+      const { promise, ...resolverMethods } = makePromiseKit();
+      void promise.catch(() => {});
+      const resolver = Far('resolver', resolverMethods);
+      return harden({ promise, resolver });
+    },
+
+    makeUnsettledPromise() {
+      const { promise } = makePromiseKit();
+      void promise.catch(() => {});
+      return promise;
+    },
+
+    /**
+     * Returns a remotable with methods that return provided values. Invocations
+     * of those methods and their arguments are captured for later retrieval by
+     * `getCallLogForRemotable`.
+     *
+     * @param {string} [label]
+     * @param {Record<string, any>} [fields]
+     */
+    makeRemotable: (label = 'Remotable', fields = {}) => {
+      /** @type {CallLog} */
+      const callLog = [];
+      const methods = objectMap(fields, (value, name) =>
+        makeSpy(value, name, callLog),
+      );
+      const remotable = Far(label, { ...methods });
+      callLogsByRemotable.set(remotable, callLog);
+      return remotable;
+    },
+
+    /**
+     * @param {object} remotable
+     * @returns {CallLog}
+     */
+    getCallLogForRemotable: remotable =>
+      callLogsByRemotable.get(remotable) ||
+      Fail`unknown remotable ${q(remotable)}`,
+  };
+};
+harden(makeReflectionMethods);
+
+export function buildRootObject(vatPowers, _vatParameters, baggage) {
+  const methods = makeReflectionMethods(vatPowers, baggage);
+  return Far('root', methods);
+}