@agoric/vats 0.15.1-dev-779b73d.0 → 0.15.1-dev-3353509.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/vats",
-  "version": "0.15.1-dev-779b73d.0+779b73d",
+  "version": "0.15.1-dev-3353509.0+3353509",
   "description": "Agoric's Vat library",
   "type": "module",
   "main": "./index.js",
@@ -28,19 +28,19 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-779b73d.0+779b73d",
-    "@agoric/ertp": "0.16.3-dev-779b73d.0+779b73d",
-    "@agoric/governance": "0.10.3-dev-779b73d.0+779b73d",
-    "@agoric/inter-protocol": "0.16.1-dev-779b73d.0+779b73d",
-    "@agoric/internal": "0.3.3-dev-779b73d.0+779b73d",
-    "@agoric/notifier": "0.6.3-dev-779b73d.0+779b73d",
-    "@agoric/sharing-service": "0.2.12-dev-779b73d.0+779b73d",
-    "@agoric/store": "0.9.3-dev-779b73d.0+779b73d",
-    "@agoric/swingset-vat": "0.32.3-dev-779b73d.0+779b73d",
-    "@agoric/time": "0.3.3-dev-779b73d.0+779b73d",
-    "@agoric/vat-data": "0.5.3-dev-779b73d.0+779b73d",
-    "@agoric/zoe": "0.26.3-dev-779b73d.0+779b73d",
-    "@agoric/zone": "0.2.3-dev-779b73d.0+779b73d",
+    "@agoric/assert": "0.6.1-dev-3353509.0+3353509",
+    "@agoric/ertp": "0.16.3-dev-3353509.0+3353509",
+    "@agoric/governance": "0.10.3-dev-3353509.0+3353509",
+    "@agoric/inter-protocol": "0.16.1-dev-3353509.0+3353509",
+    "@agoric/internal": "0.3.3-dev-3353509.0+3353509",
+    "@agoric/notifier": "0.6.3-dev-3353509.0+3353509",
+    "@agoric/sharing-service": "0.2.12-dev-3353509.0+3353509",
+    "@agoric/store": "0.9.3-dev-3353509.0+3353509",
+    "@agoric/swingset-vat": "0.32.3-dev-3353509.0+3353509",
+    "@agoric/time": "0.3.3-dev-3353509.0+3353509",
+    "@agoric/vat-data": "0.5.3-dev-3353509.0+3353509",
+    "@agoric/zoe": "0.26.3-dev-3353509.0+3353509",
+    "@agoric/zone": "0.2.3-dev-3353509.0+3353509",
     "@endo/far": "^0.2.18",
     "@endo/import-bundle": "^0.3.4",
     "@endo/init": "^0.5.56",
@@ -50,11 +50,11 @@
     "jessie.js": "^0.3.2"
   },
   "devDependencies": {
-    "@agoric/cosmic-swingset": "0.41.3-dev-779b73d.0+779b73d",
-    "@agoric/deploy-script-support": "0.10.3-dev-779b73d.0+779b73d",
-    "@agoric/smart-wallet": "0.5.3-dev-779b73d.0+779b73d",
-    "@agoric/swing-store": "0.9.2-dev-779b73d.0+779b73d",
-    "@agoric/swingset-liveslots": "0.10.3-dev-779b73d.0+779b73d",
+    "@agoric/cosmic-swingset": "0.41.3-dev-3353509.0+3353509",
+    "@agoric/deploy-script-support": "0.10.3-dev-3353509.0+3353509",
+    "@agoric/smart-wallet": "0.5.3-dev-3353509.0+3353509",
+    "@agoric/swing-store": "0.9.2-dev-3353509.0+3353509",
+    "@agoric/swingset-liveslots": "0.10.3-dev-3353509.0+3353509",
     "@endo/bundle-source": "^2.5.1",
     "@endo/captp": "^3.1.1",
     "@endo/stream": "^0.3.25",
@@ -65,6 +65,8 @@
   "files": [
     "CHANGELOG.md",
     "src/",
+    "scripts/",
+    "tools/",
     "*.json",
     "globals.d.ts",
     "exported.js"
@@ -83,5 +85,5 @@
     "timeout": "20m",
     "workerThreads": false
   },
-  "gitHead": "779b73d11992c1e00cfe99bfe3444081107a34a1"
+  "gitHead": "33535095a838565aa9ae7aa1234669ed68b4bb9d"
 }

package/scripts/build-bundles.d.ts

@@ -0,0 +1,3 @@
+#! /usr/bin/env node
+export {};
+//# sourceMappingURL=build-bundles.d.ts.map

package/scripts/build-bundles.d.ts.map

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

package/scripts/build-bundles.js

@@ -0,0 +1,14 @@
+#! /usr/bin/env node
+import '@endo/init';
+import { createBundles } from '@agoric/internal/src/node/createBundles.js';
+import url from 'url';
+
+const dirname = url.fileURLToPath(new URL('.', import.meta.url));
+
+const sourceToBundle = [
+  [`../src/centralSupply.js`, `../bundles/bundle-centralSupply.js`],
+  [`../src/mintHolder.js`, `../bundles/bundle-mintHolder.js`],
+  [`../src/provisionPool.js`, `../bundles/bundle-provisionPool.js`],
+];
+
+await createBundles(sourceToBundle, dirname);

package/scripts/init-core.d.ts

@@ -0,0 +1,5 @@
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').ProposalBuilder} */
+export const defaultProposalBuilder: import('@agoric/deploy-script-support/src/externalTypes.js').ProposalBuilder;
+declare function _default(homeP: any, endowments: any): Promise<void>;
+export default _default;
+//# sourceMappingURL=init-core.d.ts.map

package/scripts/init-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-core.d.ts","sourceRoot":"","sources":["init-core.js"],"names":[],"mappings":"AAEA,2FAA2F;AAC3F,qCADW,OAAO,oDAAoD,EAAE,eAAe,CAuBlF;AAEU,sEAGd"}

package/scripts/init-core.js

@@ -0,0 +1,31 @@
+import { makeHelpers } from '@agoric/deploy-script-support';
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').ProposalBuilder} */
+export const defaultProposalBuilder = async ({ publishRef, install }) =>
+  harden({
+    sourceSpec: '../src/core/startWalletFactory.js',
+    getManifestCall: [
+      'getManifestForWalletFactory',
+      {
+        installKeys: {
+          provisionPool: publishRef(
+            install(
+              '../src/provisionPool.js',
+              '../bundles/bundle-provisionPool.js',
+            ),
+          ),
+          walletFactory: publishRef(
+            install(
+              '@agoric/smart-wallet/src/walletFactory.js',
+              '../../smart-wallet/bundles/bundle-walletFactory.js',
+            ),
+          ),
+        },
+      },
+    ],
+  });
+
+export default async (homeP, endowments) => {
+  const { writeCoreProposal } = await makeHelpers(homeP, endowments);
+  await writeCoreProposal('gov-vats', defaultProposalBuilder);
+};

package/scripts/init-network.d.ts

@@ -0,0 +1,5 @@
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').ProposalBuilder} */
+export const defaultProposalBuilder: import('@agoric/deploy-script-support/src/externalTypes.js').ProposalBuilder;
+declare function _default(homeP: any, endowments: any): Promise<void>;
+export default _default;
+//# sourceMappingURL=init-network.d.ts.map

package/scripts/init-network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-network.d.ts","sourceRoot":"","sources":["init-network.js"],"names":[],"mappings":"AAEA,2FAA2F;AAC3F,qCADW,OAAO,oDAAoD,EAAE,eAAe,CAWlF;AAEU,sEAGd"}

package/scripts/init-network.js

@@ -0,0 +1,19 @@
+import { makeHelpers } from '@agoric/deploy-script-support';
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').ProposalBuilder} */
+export const defaultProposalBuilder = async ({ publishRef, install }) =>
+  harden({
+    sourceSpec: '../src/proposals/network-proposal.js',
+    getManifestCall: [
+      'getManifestForNetwork',
+      {
+        networkRef: publishRef(install('../src/vat-network.js')),
+        ibcRef: publishRef(install('../src/vat-ibc.js')),
+      },
+    ],
+  });
+
+export default async (homeP, endowments) => {
+  const { writeCoreProposal } = await makeHelpers(homeP, endowments);
+  await writeCoreProposal('gov-network', defaultProposalBuilder);
+};

package/scripts/restart-vats.d.ts

@@ -0,0 +1,5 @@
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').ProposalBuilder} */
+export const defaultProposalBuilder: import('@agoric/deploy-script-support/src/externalTypes.js').ProposalBuilder;
+declare function _default(homeP: any, endowments: any): Promise<void>;
+export default _default;
+//# sourceMappingURL=restart-vats.d.ts.map

package/scripts/restart-vats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restart-vats.d.ts","sourceRoot":"","sources":["restart-vats.js"],"names":[],"mappings":"AAEA,2FAA2F;AAC3F,qCADW,OAAO,oDAAoD,EAAE,eAAe,CAerF;AAEa,sEAGd"}

package/scripts/restart-vats.js

@@ -0,0 +1,23 @@
+import { makeHelpers } from '@agoric/deploy-script-support';
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').ProposalBuilder} */
+export const defaultProposalBuilder = async () => {
+  // An includelist isn't necessary because the collections are known to be complete (tested in test-vaults-upgrade.js)
+  const skip = [
+    // can be replaced instead of upgraded
+    'auctioneer',
+    'feeDistributor',
+    // skip so vaultManager can have prices upon restart; these have been tested as restartable
+    'scaledPriceAuthority-ATOM',
+  ];
+
+  return harden({
+    sourceSpec: '../src/proposals/restart-vats-proposal.js',
+    getManifestCall: ['getManifestForRestart', harden({ skip })],
+  });
+};
+
+export default async (homeP, endowments) => {
+  const { writeCoreProposal } = await makeHelpers(homeP, endowments);
+  await writeCoreProposal('restart-vats', defaultProposalBuilder);
+};

package/scripts/set-core-proposal-env.d.ts

@@ -0,0 +1,3 @@
+#! /usr/bin/env node
+export {};
+//# sourceMappingURL=set-core-proposal-env.d.ts.map

package/scripts/set-core-proposal-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-core-proposal-env.d.ts","sourceRoot":"","sources":["set-core-proposal-env.js"],"names":[],"mappings":""}

package/scripts/set-core-proposal-env.js

@@ -0,0 +1,37 @@
+#! /usr/bin/env node
+import fs from 'fs';
+import process from 'process';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const spec = process.argv[2];
+if (!spec) {
+  process.exit(0);
+}
+
+const vatConfigFile = require.resolve(spec);
+const configJson = fs.readFileSync(vatConfigFile);
+const config = JSON.parse(configJson);
+
+const envs = new Map();
+if (Array.isArray(config?.coreProposals)) {
+  config.coreProposals.forEach(
+    ({ env }) =>
+      env &&
+      Object.entries(env).forEach(([key, val]) => {
+        const oldVal = envs.get(key);
+        if (envs.has(key) && oldVal !== val) {
+          throw Error(
+            `Duplicate env key: ${key}, but value is ${val} not ${oldVal}`,
+          );
+        }
+        envs.set(key, val);
+      }),
+  );
+}
+
+for (const [key, val] of envs.entries()) {
+  process.stdout.write(
+    `${key}="${val.replace(/(\\)/g, '\\$1').replace(/(")/g, '\\$1')}"\n`,
+  );
+}

package/tools/authorityViz.d.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+export type GraphNode = {
+    id: string;
+    cluster?: string;
+    label: string;
+    style?: string;
+};
+export type Permit = true | ({
+    vatParameters?: Record<string, Permit>;
+    vatPowers?: Record<string, true>;
+    vats?: Record<string, Status>;
+    devices?: Record<string, true>;
+    home?: PowerSpace;
+    issuer?: PowerSpace;
+    brand?: PowerSpace;
+    oracleBrand?: PowerSpace;
+    installation?: PowerSpace;
+    instance?: PowerSpace;
+} & PowerSpace);
+export type PowerSpace = {
+    produce?: Record<string, Status>;
+    consume?: Record<string, Status>;
+};
+export type Status = boolean | VatName;
+export type VatName = string;
+export type Resolver = (specifier: string, parent: string) => Promise<string>;
+//# sourceMappingURL=authorityViz.d.ts.map

package/tools/authorityViz.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorityViz.d.ts","sourceRoot":"","sources":["authorityViz.js"],"names":[],"mappings":";wBA6Ba;IACZ,EAAM,EAAE,MAAM,CAAC;IACf,OAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAS,EAAE,MAAM,CAAC;IAClB,KAAS,CAAC,EAAE,MAAM,CAAC;CAChB;qBAiCU,IAAI,IAAG;IACpB,aAAiB,CAAC,EAAE,OAAO,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,SAAa,CAAC,EAAE,OAAO,MAAM,EAAE,IAAI,CAAC,CAAA;IACpC,IAAQ,CAAC,EAAE,OAAO,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,OAAW,CAAC,EAAE,OAAO,MAAM,EAAE,IAAI,CAAC,CAAA;IAClC,IAAQ,CAAC,EAAE,UAAU,CAAC;IACtB,MAAU,CAAC,EAAE,UAAU,CAAC;IACxB,KAAS,CAAC,EAAE,UAAU,CAAC;IACvB,WAAe,CAAC,EAAE,UAAU,CAAC;IAC7B,YAAgB,CAAC,EAAE,UAAU,CAAC;IAC9B,QAAY,CAAC,EAAE,UAAU,CAAC;CACvB,GAAG,UAAU,CAAA;yBACJ;IAAC,OAAO,CAAC,EAAE,OAAO,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,MAAM,EAAE,MAAM,CAAC,CAAA;CAAC;qBACnE,OAAO,GAAG,OAAO;sBACjB,MAAM;mCA0IK,MAAM,UAAU,MAAM,KAAK,QAAQ,MAAM,CAAC"}

package/tools/authorityViz.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+// @ts-check
+import '@endo/init';
+import process from 'process';
+
+const { entries, keys, values } = Object;
+
+const logged = label => x => {
+  console.error(label, x);
+  return x;
+};
+
+const styles = {
+  vatPowers: 'shape=star, style=filled, fillcolor=aqua',
+  vats: 'shape=doubleoctagon, style=filled, fillcolor=tomato',
+  vat: 'shape=doubleoctagon, style=filled, fillcolor=tomato3',
+  devices: 'shape=box, style=filled, fillcolor=gold',
+  space: 'shape=house, style=filled, fillcolor=khaki',
+  issuer: 'shape=trapezium, style=filled, fillcolor=chocolate',
+  brand: 'shape=Mcircle, style=filled, fillcolor=chocolate2',
+  installation: 'shape=cylinder',
+  instance: 'shape=component',
+  home: 'shape=folder',
+};
+
+/**
+ * @param {Set<GraphNode>} nodes
+ * @param {Map<string, Set<{ id: string, style?: string }>>} neighbors
+ * @yields { string }
+ * @typedef {{
+ *   id: string,
+ *   cluster?: string,
+ *   label: string,
+ *   style?: string,
+ * }} GraphNode
+ */
+function* fmtGraph(nodes, neighbors) {
+  const q = txt => JSON.stringify(txt.replace(/\./g, '_'));
+  yield 'digraph G {\n';
+  yield 'rankdir = LR;\n';
+  const clusters = new Set(
+    [...nodes].map(({ cluster }) => cluster).filter(c => !!c),
+  );
+  for (const subgraph of [...clusters, undefined]) {
+    if (subgraph) {
+      assert.typeof(subgraph, 'string');
+      yield `subgraph cluster_${subgraph} {\n`;
+      yield `label = "${subgraph}"\n`;
+    }
+    for (const { id, cluster, label, style } of nodes) {
+      if (subgraph && cluster !== subgraph) continue;
+      yield `${q(id)} [label=${q(label)}${style ? `, ${style}` : ''}];\n`;
+    }
+    if (subgraph) {
+      yield `}\n`;
+    }
+  }
+  for (const [src, arcs] of neighbors.entries()) {
+    for (const { id, style } of arcs) {
+      yield `${q(src)} -> ${q(id)} [${style}]\n`;
+    }
+  }
+  yield '}\n';
+}
+
+/**
+ * @param {Record<string, Permit>} manifest
+ * @typedef { true | {
+ *   vatParameters?: Record<string, Permit>,
+ *   vatPowers?: Record<string, true>
+ *   vats?: Record<string, Status>
+ *   devices?: Record<string, true>
+ *   home?: PowerSpace,
+ *   issuer?: PowerSpace,
+ *   brand?: PowerSpace,
+ *   oracleBrand?: PowerSpace,
+ *   installation?: PowerSpace,
+ *   instance?: PowerSpace,
+ * } & PowerSpace } Permit
+ * @typedef {{produce?: Record<string, Status>, consume?: Record<string, Status>}} PowerSpace
+ * @typedef { boolean | VatName } Status
+ * @typedef { string } VatName
+ */
+const manifest2graph = manifest => {
+  /** @type { Set<GraphNode> } */
+  const nodes = new Set();
+  const neighbors = new Map();
+
+  /**
+   * @param {string} src
+   * @param {string} dest
+   * @param {string} [style]
+   */
+  const addEdge = (src, dest, style = '') => {
+    logged('addEdge')({ src, dest });
+    if (!neighbors.has(src)) {
+      neighbors.set(src, new Set());
+    }
+    neighbors.get(src).add({ id: dest, style });
+  };
+
+  /**
+   * @param {string} src
+   * @param {string} ty
+   * @param {Permit} item
+   * @param {boolean} [reverse=false]
+   */
+  const level1 = (src, ty, item, reverse = false) => {
+    if (!item) return;
+    for (const [powerName, status] of entries(item)) {
+      // subsumed by permits for vat:, home:, ...
+      if (
+        [
+          'loadVat',
+          'loadCriticalVat',
+          'client',
+          'agoricNames',
+          'nameHubs',
+          'nameAdmins',
+        ].includes(powerName) &&
+        reverse
+      )
+        continue;
+      if (status) {
+        let cluster = {};
+        if (typeof status !== 'boolean') {
+          cluster = { cluster: status };
+        }
+
+        nodes.add({
+          id: `${ty}.${powerName}`,
+          label: powerName,
+          style: styles[ty],
+          ...cluster,
+        });
+        addEdge(src, `${ty}.${powerName}`, reverse ? 'dir=back' : '');
+        if (ty === 'home') {
+          nodes.add({ id: 'home', label: 'home', cluster: 'provisioning' });
+          addEdge('home', `${ty}.${powerName}`);
+        }
+      }
+    }
+  };
+
+  /** @type {<X>(xs: X[]) => X[]} */
+  const uniq = xs => [...new Set(xs)];
+  const spaces = uniq(
+    logged('vals')(values(manifest)).flatMap(permit =>
+      logged('keys?')(keys(permit)).flatMap(name => {
+        logged('name?')(name);
+
+        if (['produce', 'consume'].includes(name)) return [];
+        return [name];
+      }),
+    ),
+  );
+  console.error('@@@', { spaces });
+
+  for (const [fnName, permit] of entries(manifest)) {
+    if (permit === true) {
+      console.error('skipping wildcard permit:', fnName);
+      continue;
+    }
+    nodes.add({ id: logged('fn')(fnName), label: fnName });
+
+    permit.vatPowers && level1(fnName, 'vatPowers', permit.vatPowers, true);
+    permit.vats && level1(fnName, 'vats', permit.vats, true);
+    permit.devices && level1(fnName, 'devices', permit.devices, true);
+
+    const doPart = (name, part) => {
+      if (!part) return;
+      level1(fnName, name, part.produce || {});
+      level1(fnName, name, part.consume || {}, true);
+    };
+    doPart('space', permit);
+    spaces.forEach(s => doPart(s, permit[s]));
+
+    if ('runBehaviors' in permit) {
+      throw Error('not impl');
+      // nodes.add({
+      //   id: `runBehaviors`,
+      //   label: `runBehaviors`,
+      //   style: '',
+      // });
+      // addEdge(fnName, `runBehaviors`);
+    }
+  }
+  return { nodes, neighbors };
+};
+
+const { Fail, quote: q } = assert;
+
+/**
+ * @param {string} specifier
+ * @param {object} io
+ * @param {Resolver} io.resolve
+ * @param {typeof import('fs/promises').readFile} io.readFile
+ */
+const loadConfig = async (specifier, { resolve, readFile }) => {
+  const fullPath = await resolve(specifier, import.meta.url).then(
+    u => new URL(u).pathname,
+  );
+  typeof fullPath === 'string' || Fail`${q(specifier)}`;
+  const txt = await readFile(fullPath, 'utf-8');
+  typeof txt === 'string' || Fail`readFile ${q(fullPath)}`;
+  return JSON.parse(txt);
+};
+
+/**
+ * @param {string[]} args
+ * @param {object} io
+ * @param {typeof import('process').stdout} io.stdout
+ * @param {typeof import('fs/promises')} io.fsp
+ * @param {{
+ *   resolve: Resolver,
+ *   url: string,
+ *   load: (specifier: string) => Promise<Record<string, any>>,
+ * }} io.meta
+ *
+ * @typedef {(specifier: string, parent: string) => Promise<string>} Resolver
+ */
+const main = async (args, { stdout, fsp, meta }) => {
+  const [specifier, ...opts] = args;
+  specifier || Fail`Usage: $0 @agoric/vats/decentral-...json`;
+
+  const config = await loadConfig(specifier, {
+    resolve: meta.resolve,
+    readFile: fsp.readFile,
+  });
+  // console.log(config);
+  const { bootstrap } = config.vats;
+
+  const { MANIFEST } = await meta
+    .resolve(bootstrap.sourceSpec, meta.url)
+    .then(p => meta.load(p));
+  // console.log('manifest keys:', Object.keys(MANIFEST));
+
+  const [gov] = ['--gov'].map(opt => opts.includes(opt));
+
+  if (gov) {
+    throw Error('not impl');
+    /*
+    const postBoot = sim
+      ? manifests.SIM_CHAIN_POST_BOOT_MANIFEST
+      : manifests.CHAIN_POST_BOOT_MANIFEST;
+    manifest = { ...postBoot, ...manifest };
+    */
+  }
+
+  const g = manifest2graph(MANIFEST);
+  for (const chunk of fmtGraph(g.nodes, g.neighbors)) {
+    stdout.write(chunk);
+  }
+};
+
+(async () => {
+  await Promise.all([
+    import('fs/promises'),
+    // eslint-disable-next-line import/no-extraneous-dependencies
+    import('import-meta-resolve'),
+  ]).then(([fsp, metaResolve]) => {
+    return main(process.argv.slice(2), {
+      stdout: process.stdout,
+      fsp,
+      meta: {
+        resolve: metaResolve.resolve,
+        url: import.meta.url,
+        load: specifier => import(specifier),
+      },
+    });
+  });
+})().catch(console.error);

package/tools/bank-utils.d.ts

@@ -0,0 +1,6 @@
+export function makeFakeBankKit(issuerKits: Array<Pick<IssuerKit, 'brand' | 'issuer'>>): {
+    addAsset: (denom: string, issuerName: string, proposedName: string, kit: import('../src/vat-bank.js').AssetIssuerKit) => void;
+    assetPublication: IterationObserver<import("../src/vat-bank.js").AssetDescriptor>;
+    bank: import("../src/vat-bank.js").Bank;
+};
+//# sourceMappingURL=bank-utils.d.ts.map

package/tools/bank-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bank-utils.d.ts","sourceRoot":"","sources":["bank-utils.js"],"names":[],"mappings":"AASO,4CAFI,MAAM,KAAK,SAAS,EAAE,OAAO,GAAG,QAAQ,CAAC,CAAC;sBAmBxC,MAAM,cACN,MAAM,gBACN,MAAM,OACN,OAAO,oBAAoB,EAAE,cAAc;;;EAqBvD"}

package/tools/bank-utils.js

@@ -0,0 +1,51 @@
+// @ts-check
+import { makeSubscriptionKit } from '@agoric/notifier';
+import { makeScalarMapStore } from '@agoric/vat-data';
+import { E } from '@endo/far';
+import { Far } from '@endo/marshal';
+
+/**
+ * @param {Array<Pick<IssuerKit, 'brand' | 'issuer'>>} issuerKits
+ */
+export const makeFakeBankKit = issuerKits => {
+  /** @type {MapStore<Brand, ERef<Issuer>>} */
+  const issuers = makeScalarMapStore();
+  /** @type {MapStore<Brand, ERef<import('../src/vat-bank.js').VirtualPurse>>} */
+  const purses = makeScalarMapStore();
+
+  // XXX setup purses without publishing
+  issuerKits.forEach(kit => issuers.init(kit.brand, kit.issuer));
+  issuerKits.forEach(kit => {
+    assert(kit.issuer);
+    purses.init(kit.brand, E(kit.issuer).makeEmptyPurse());
+  });
+
+  /** @type {SubscriptionRecord<import('../src/vat-bank.js').AssetDescriptor>} */
+  const { subscription, publication } = makeSubscriptionKit();
+
+  /**
+   * @param {string} denom lower-level denomination string
+   * @param {string} issuerName
+   * @param {string} proposedName
+   * @param {import('../src/vat-bank.js').AssetIssuerKit} kit ERTP issuer kit
+   */
+  const addAsset = (denom, issuerName, proposedName, kit) => {
+    issuers.init(kit.brand, kit.issuer);
+    purses.init(kit.brand, E(kit.issuer).makeEmptyPurse());
+    publication.updateState({
+      ...kit,
+      denom,
+      issuerName,
+      proposedName,
+    });
+  };
+
+  /** @type {import('../src/vat-bank.js').Bank} */
+  const bank = Far('mock bank', {
+    /** @param {Brand} brand */
+    getPurse: async brand => purses.get(brand),
+    getAssetSubscription: () => subscription,
+  });
+
+  return { addAsset, assetPublication: publication, bank };
+};

package/tools/board-utils.d.ts

@@ -0,0 +1,53 @@
+export function makeBoardRemote({ boardId, iface }: any): BoardRemote;
+export function slotToBoardRemote(boardId: any, iface: any): BoardRemote;
+export function boardValToSlot(val: any): any;
+export function makeAgoricNamesRemotesFromFakeStorage(fakeStorageKit: import("@agoric/internal/src/storage-test-utils.js").FakeStorageKit): AgoricNamesRemotes;
+export function boardSlottingMarshaller(slotToVal?: ((slot: string, iface: string) => any) | undefined): Omit<import('@endo/marshal').Marshal<string>, 'serialize' | 'unserialize'>;
+export function makeHistoryReviver(entries: Array<[string, string]>, slotToVal?: ((slot: string, iface?: string) => any) | undefined): {
+    getItem: (key: any) => any;
+    children: (prefix: any) => string[];
+    has: (k: any) => boolean;
+};
+export function makeFakeBoard(initSequence?: number | bigint | undefined, options?: {
+    prefix?: string | undefined;
+    crcDigits?: number | undefined;
+} | undefined): {
+    getId(value: any): string;
+    getValue(id: string): any;
+    lookup(...path: string[]): Promise<any>;
+    has(val: any): boolean;
+    ids(): string[];
+    getPublishingMarshaller(): {
+        toCapData(val: any): import("@endo/marshal").CapData<string>;
+        fromCapData(data: any): any;
+        serialize(data: any): import("@endo/marshal").CapData<string>;
+        unserialize(data: any): any;
+    };
+    getReadonlyMarshaller(): {
+        toCapData(val: any): import("@endo/marshal").CapData<string | null>;
+        fromCapData(data: any): any;
+        serialize(data: any): import("@endo/marshal").CapData<string | null>;
+        unserialize(data: any): any;
+    };
+};
+/**
+ * Should be a union with Remotable, but that's `any`, making this type meaningless
+ */
+export type BoardRemote = {
+    getBoardId: () => string;
+};
+export type VBankAssetDetail = {
+    brand: BoardRemote & Brand;
+    denom: string;
+    displayInfo: DisplayInfo;
+    issuer: BoardRemote & Issuer;
+    issuerName: string;
+    proposedName: string;
+};
+export type AgoricNamesRemotes = {
+    brand: Record<string, Brand>;
+    instance: Record<string, Instance>;
+    vbankAsset: Record<string, VBankAssetDetail>;
+    reverse: Record<string, string>;
+};
+//# sourceMappingURL=board-utils.d.ts.map

package/tools/board-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"board-utils.d.ts","sourceRoot":"","sources":["board-utils.js"],"names":[],"mappings":"AAoCO,0DAFM,WAAW,CAKvB;AAEM,yEAC8B;AAE9B,8CAKN;AAMM,sEAHI,OAAO,4CAA4C,EAAE,cAAc,GACjE,kBAAkB,CAmC9B;AAYM,4DAHW,MAAM,SAAS,MAAM,KAAK,GAAG,gBAClC,KAAK,OAAO,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,aAAa,CAAC,CAMtF;AAQM,4CAHI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,sBAChB,MAAM,UAAU,MAAM,KAAK,GAAG;;;;EAoB/C;AAWM;;;;;;;;;;;;;;;;;;;;;EAGN;;;;0BA5IY;IAAE,UAAU,EAAE,MAAM,MAAM,CAAA;CAAE;+BAG5B;IACZ,KAAS,EAAE,WAAW,GAAG,KAAK,CAAC;IAC/B,KAAS,EAAE,MAAM,CAAC;IAClB,WAAe,EAAE,WAAW,CAAC;IAC7B,MAAU,EAAE,WAAW,GAAG,MAAM,CAAC;IACjC,UAAc,EAAE,MAAM,CAAC;IACvB,YAAgB,EAAE,MAAM,CAAC;CACtB;iCAGS;IACZ,KAAS,EAAE,OAAO,MAAM,EAAE,KAAK,CAAC,CAAC;IACjC,QAAY,EAAE,OAAO,MAAM,EAAE,QAAQ,CAAC,CAAC;IACvC,UAAc,EAAE,OAAO,MAAM,EAAE,gBAAgB,CAAC,CAAC;IACjD,OAAW,EAAE,OAAO,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC"}

package/tools/board-utils.js

@@ -0,0 +1,145 @@
+// @ts-check
+/**
+ * Should be a union with Remotable, but that's `any`, making this type meaningless
+ *
+ * @typedef {{ getBoardId: () => string }} BoardRemote
+ */
+/**
+ * @typedef {{
+ *   brand: BoardRemote & Brand,
+ *   denom: string,
+ *   displayInfo: DisplayInfo,
+ *   issuer: BoardRemote & Issuer,
+ *   issuerName: string,
+ *   proposedName: string,
+ * }} VBankAssetDetail
+ */
+/**
+ * @typedef {{
+ *   brand: Record<string, Brand>,
+ *   instance: Record<string, Instance>,
+ *   vbankAsset: Record<string, VBankAssetDetail>,
+ *   reverse: Record<string, string>,
+ * }} AgoricNamesRemotes
+ */
+
+import { Fail } from '@agoric/assert';
+import { unmarshalFromVstorage } from '@agoric/internal/src/lib-chainStorage.js';
+import { makeScalarBigMapStore } from '@agoric/vat-data';
+import { Far } from '@endo/far';
+import { makeMarshal } from '@endo/marshal';
+import { prepareBoardKit } from '../src/lib-board.js';
+
+/**
+ * @param {*} slotInfo
+ * @returns {BoardRemote}
+ */
+export const makeBoardRemote = ({ boardId, iface }) => {
+  const nonalleged = iface ? iface.replace(/^Alleged: /, '') : '';
+  return Far(`BoardRemote${nonalleged}`, { getBoardId: () => boardId });
+};
+
+export const slotToBoardRemote = (boardId, iface) =>
+  makeBoardRemote({ boardId, iface });
+
+export const boardValToSlot = val => {
+  if ('getBoardId' in val) {
+    return val.getBoardId();
+  }
+  Fail`unknown obj in boardSlottingMarshaller.valToSlot ${val}`;
+};
+
+/**
+ * @param {import("@agoric/internal/src/storage-test-utils.js").FakeStorageKit} fakeStorageKit
+ * @returns {AgoricNamesRemotes}
+ */
+export const makeAgoricNamesRemotesFromFakeStorage = fakeStorageKit => {
+  const { data } = fakeStorageKit;
+
+  // this produces Remotables that can roundtrip through a
+  // boardValToSlot-using marshaller
+
+  const { fromCapData } = makeMarshal(undefined, slotToBoardRemote);
+  const reverse = {};
+  const entries = ['brand', 'instance'].map(kind => {
+    /** @type {Array<[string, import('@agoric/vats/tools/board-utils.js').BoardRemote]>} */
+    const parts = unmarshalFromVstorage(
+      data,
+      `published.agoricNames.${kind}`,
+      fromCapData,
+    );
+    for (const [name, remote] of parts) {
+      reverse[remote.getBoardId()] = name;
+    }
+    return [kind, Object.fromEntries(parts)];
+  });
+  const tables = Object.fromEntries(entries);
+  // XXX not part of reverse[]
+  const vbankAsset = Object.fromEntries(
+    unmarshalFromVstorage(
+      data,
+      `published.agoricNames.vbankAsset`,
+      fromCapData,
+    ).map(([_denom, info]) => [
+      info.issuerName,
+      { ...info, brand: tables.brand[info.issuerName] },
+    ]),
+  );
+  return { ...tables, reverse, vbankAsset };
+};
+harden(makeAgoricNamesRemotesFromFakeStorage);
+
+/**
+ * A marshaller which can serialize getBoardId() -bearing
+ * Remotables. This allows the caller to pick their slots. The
+ * deserializer is configurable: the default cannot handle
+ * Remotable-bearing data.
+ *
+ * @param {(slot: string, iface: string) => any} [slotToVal]
+ * @returns {Omit<import('@endo/marshal').Marshal<string>, 'serialize' | 'unserialize'>}
+ */
+export const boardSlottingMarshaller = (slotToVal = undefined) => {
+  return makeMarshal(boardValToSlot, slotToVal, {
+    serializeBodyFormat: 'smallcaps',
+  });
+};
+
+/**
+ * Provide access to object graphs serialized in vstorage.
+ *
+ * @param {Array<[string, string]>} entries
+ * @param {(slot: string, iface?: string) => any} [slotToVal]
+ */
+export const makeHistoryReviver = (entries, slotToVal = undefined) => {
+  const board = boardSlottingMarshaller(slotToVal);
+  const vsMap = new Map(entries);
+  const fromCapData = (...args) =>
+    Reflect.apply(board.fromCapData, board, args);
+  const getItem = key => unmarshalFromVstorage(vsMap, key, fromCapData);
+  const children = prefix => {
+    prefix.endsWith('.') || Fail`prefix must end with '.'`;
+    return harden([
+      ...new Set(
+        entries
+          .map(([k, _]) => k)
+          .filter(k => k.startsWith(prefix))
+          .map(k => k.slice(prefix.length).split('.')[0]),
+      ),
+    ]);
+  };
+  return harden({ getItem, children, has: k => vsMap.get(k) !== undefined });
+};
+
+/**
+ * Make a board that uses durable storage, but with fake baggage which will fail upgrade.
+ * Suitable only for use in tests.
+ *
+ * @param {bigint | number} [initSequence]
+ * @param {object} [options]
+ * @param {string} [options.prefix]
+ * @param {number} [options.crcDigits]
+ */
+export const makeFakeBoard = (initSequence = 0, options = {}) => {
+  const make = prepareBoardKit(makeScalarBigMapStore('baggage'));
+  return make(initSequence, options).board;
+};

package/tools/boot-test-utils.d.ts

@@ -0,0 +1,163 @@
+export namespace vatRoots {
+    export { agoricNamesRoot as agoricNames };
+    export { bankRoot as bank };
+    export { boardRoot as board };
+    export { ibcRoot as ibc };
+    export { mintsRoot as mints };
+    export { networkRoot as network };
+    export { priceAuthorityRoot as priceAuthority };
+    export { provisioningRoot as provisioning };
+    export { zoeRoot as zoe };
+}
+export function noop(): void;
+/** @type {DProxy} */
+export const mockDProxy: DProxy;
+export function makeMock(log: any): {
+    devices: {
+        vatAdmin: {
+            getNamedBundleCap: (name: any) => {
+                getBundle: () => any;
+            };
+        };
+        command: any;
+        mailbox: any;
+        timer: any;
+        plugin: any;
+    };
+    vats: {
+        vattp: any;
+        comms: {
+            addRemote: () => void;
+            addEgress: () => void;
+            addIngress: () => Promise<{
+                getConfiguration: () => {
+                    _: string;
+                };
+            }>;
+        } & import("@endo/eventual-send").RemotableBrand<{}, {
+            addRemote: () => void;
+            addEgress: () => void;
+            addIngress: () => Promise<{
+                getConfiguration: () => {
+                    _: string;
+                };
+            }>;
+        }>;
+        http: {
+            setPresences: () => void;
+            setCommandDevice: () => void;
+        };
+        spawner: {
+            buildSpawner: () => {
+                _: string;
+            };
+        };
+        timer: {
+            createTimerService: () => Promise<ManualTimer>;
+        } & import("@endo/eventual-send").RemotableBrand<{}, {
+            createTimerService: () => Promise<ManualTimer>;
+        }>;
+        uploads: {
+            getUploads: () => {
+                _: string;
+            };
+        };
+        network: {
+            registerProtocolHandler: () => void;
+            bind: () => {
+                addListener: () => void;
+            };
+        } & import("@endo/eventual-send").RemotableBrand<{}, {
+            registerProtocolHandler: () => void;
+            bind: () => {
+                addListener: () => void;
+            };
+        }>;
+    };
+};
+export function makePopulatedFakeVatAdmin(): {
+    vatAdminService: {
+        createVat: (bundleCap: any, options: any) => Promise<{
+            root: unknown;
+            adminNode: {
+                done: () => Promise<any>;
+                terminateWithFailure: () => void;
+                upgrade: (_bundleCap: any, _options: any) => never;
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                done: () => Promise<any>;
+                terminateWithFailure: () => void;
+                upgrade: (_bundleCap: any, _options: any) => never;
+            }>;
+        }> | {
+            root: any;
+            adminNode: import("@agoric/swingset-vat").VatAdminFacet;
+        };
+        createVatByName: (name: any) => Promise<{
+            root: unknown;
+            adminNode: {
+                done: () => Promise<any>;
+                terminateWithFailure: () => void;
+                upgrade: (_bundleCap: any, _options: any) => never;
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                done: () => Promise<any>;
+                terminateWithFailure: () => void;
+                upgrade: (_bundleCap: any, _options: any) => never;
+            }>;
+        } | {
+            root: any;
+            adminNode: import("@agoric/swingset-vat").VatAdminFacet;
+        }>;
+        getBundleCap: (bundleID: any) => Promise<any>;
+        waitForBundleCap: (bundleID: any) => Promise<any>;
+        getNamedBundleCap: (name: any) => Promise<any>;
+        getBundleIDByName: (name: any) => Promise<string>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        createVat: (bundleCap: any, options: any) => Promise<{
+            root: unknown;
+            adminNode: {
+                done: () => Promise<any>;
+                terminateWithFailure: () => void;
+                upgrade: (_bundleCap: any, _options: any) => never;
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                done: () => Promise<any>;
+                terminateWithFailure: () => void;
+                upgrade: (_bundleCap: any, _options: any) => never;
+            }>;
+        }> | {
+            root: any;
+            adminNode: import("@agoric/swingset-vat").VatAdminFacet;
+        };
+        createVatByName: (name: any) => Promise<{
+            root: unknown;
+            adminNode: {
+                done: () => Promise<any>;
+                terminateWithFailure: () => void;
+                upgrade: (_bundleCap: any, _options: any) => never;
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                done: () => Promise<any>;
+                terminateWithFailure: () => void;
+                upgrade: (_bundleCap: any, _options: any) => never;
+            }>;
+        } | {
+            root: any;
+            adminNode: import("@agoric/swingset-vat").VatAdminFacet;
+        }>;
+        getBundleCap: (bundleID: any) => Promise<any>;
+        waitForBundleCap: (bundleID: any) => Promise<any>;
+        getNamedBundleCap: (name: any) => Promise<any>;
+        getBundleIDByName: (name: any) => Promise<string>;
+    }>;
+    vatAdminRoot: any;
+};
+export function mockSwingsetVats(mock: any): any;
+export function mockPsmBootstrapArgs(log: (msg: string) => void): any[];
+import { buildRootObject as agoricNamesRoot } from "../src/vat-agoricNames.js";
+import { buildRootObject as bankRoot } from "../src/vat-bank.js";
+import { buildRootObject as boardRoot } from "../src/vat-board.js";
+import { buildRootObject as ibcRoot } from "../src/vat-ibc.js";
+import { buildRootObject as mintsRoot } from "../src/vat-mints.js";
+import { buildRootObject as networkRoot } from "../src/vat-network.js";
+import { buildRootObject as priceAuthorityRoot } from "../src/vat-priceAuthority.js";
+import { buildRootObject as provisioningRoot } from "../src/vat-provisioning.js";
+import { buildRootObject as zoeRoot } from "../src/vat-zoe.js";
+//# sourceMappingURL=boot-test-utils.d.ts.map

package/tools/boot-test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot-test-utils.d.ts","sourceRoot":"","sources":["boot-test-utils.js"],"names":[],"mappings":";;;;;;;;;;;AAkCO,6BAAqB;AAE5B,qBAAqB;AAErB,yBAFW,MAAM,CAEgB;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCH;AAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiEN;AAEM,iDAON;AAKM,gDAFU,MAAM,KAAK,IAAI,SAM/B"}

package/tools/boot-test-utils.js

@@ -0,0 +1,166 @@
+// @ts-check
+import {
+  makeFakeVatAdmin,
+  zcfBundleCap,
+} from '@agoric/zoe/tools/fakeVatAdmin.js';
+import buildManualTimer from '@agoric/zoe/tools/manualTimer.js';
+import { Far } from '@endo/marshal';
+import { makeScalarBigMapStore } from '@agoric/vat-data';
+import { bundles, devices } from '../test/devices.js';
+
+import { buildRootObject as agoricNamesRoot } from '../src/vat-agoricNames.js';
+import { buildRootObject as bankRoot } from '../src/vat-bank.js';
+import { buildRootObject as boardRoot } from '../src/vat-board.js';
+import { buildRootObject as ibcRoot } from '../src/vat-ibc.js';
+import { buildRootObject as mintsRoot } from '../src/vat-mints.js';
+import { buildRootObject as networkRoot } from '../src/vat-network.js';
+import { buildRootObject as priceAuthorityRoot } from '../src/vat-priceAuthority.js';
+import { buildRootObject as provisioningRoot } from '../src/vat-provisioning.js';
+import { buildRootObject as zoeRoot } from '../src/vat-zoe.js';
+
+const { Fail } = assert;
+
+export const vatRoots = {
+  agoricNames: agoricNamesRoot,
+  bank: bankRoot,
+  board: boardRoot,
+  ibc: ibcRoot,
+  mints: mintsRoot,
+  network: networkRoot,
+  priceAuthority: priceAuthorityRoot,
+  provisioning: provisioningRoot,
+  zoe: zoeRoot,
+};
+
+export const noop = () => {};
+
+/** @type {DProxy} */
+// @ts-expect-error cast
+export const mockDProxy = d => d;
+
+export const makeMock = log =>
+  harden({
+    devices: {
+      command: /** @type { any } */ ({ registerInboundHandler: noop }),
+      mailbox: /** @type { any } */ ({
+        registerInboundHandler: noop,
+      }),
+      timer: /** @type { any } */ ({}),
+      plugin: /** @type { any } */ ({ registerReceiver: noop }),
+      ...devices,
+    },
+    vats: {
+      vattp: /** @type { any } */ (
+        Far('vattp', {
+          registerMailboxDevice: noop,
+          addRemote: () => harden({}),
+        })
+      ),
+      comms: Far('comms', {
+        addRemote: noop,
+        addEgress: noop,
+        addIngress: async () =>
+          harden({
+            getConfiguration: () => harden({ _: 'client configuration' }),
+          }),
+      }),
+      http: { setPresences: noop, setCommandDevice: noop },
+      spawner: {
+        buildSpawner: () => harden({ _: 'spawner' }),
+      },
+      timer: Far('TimerVat', {
+        createTimerService: async () => buildManualTimer(log),
+      }),
+      uploads: { getUploads: () => harden({ _: 'uploads' }) },
+
+      network: Far('network', {
+        registerProtocolHandler: noop,
+        bind: () => harden({ addListener: noop }),
+      }),
+    },
+  });
+
+export const makePopulatedFakeVatAdmin = () => {
+  // The .createVat() from zoe/tools/fakeVatAdmin.js only knows how to
+  // make ZCF vats, so wrap it in a form that can create the other
+  // vats too. We have two types.
+
+  const fakeCapToName = new Map(); // cap -> name
+  const fakeNameToCap = new Map(); // name -> cap
+  const { admin: fakeVatAdmin, vatAdminState } = makeFakeVatAdmin();
+  for (const name of Object.getOwnPropertyNames(vatRoots)) {
+    // These don't have real bundles (just a buildRootObject
+    // function), but fakeVatAdmin wants to see a bundle.endoZipBase64
+    // hash, so make some fake ones.
+    const id = `id-${name}`; // fake bundleID
+    const bundle = { endoZipBase64: id };
+    const cap = vatAdminState.installNamedBundle(name, id, bundle);
+    fakeCapToName.set(cap, name);
+    fakeNameToCap.set(name, cap);
+  }
+
+  for (const [name, bundle] of Object.entries(bundles)) {
+    // These *do* have real bundles, with an ID and everything.
+    const id = bundle.endoZipBase64Sha512;
+    const cap = vatAdminState.installNamedBundle(name, id, bundle);
+    fakeCapToName.set(cap, name);
+    fakeNameToCap.set(name, cap);
+  }
+
+  const createVat = (bundleCap, options) => {
+    assert(bundleCap);
+    if (bundleCap === zcfBundleCap) {
+      return fakeVatAdmin.createVat(zcfBundleCap, options);
+    }
+    const name = fakeCapToName.get(bundleCap);
+    assert(name);
+    const buildRoot = vatRoots[name];
+    if (!buildRoot) {
+      throw Error(`TODO: load vat ${name}`);
+    }
+    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';
+    }
+    const baggage = makeScalarBigMapStore('baggage');
+    const adminNode =
+      /** @type {import('@agoric/swingset-vat').VatAdminFacet} */ ({});
+    return { root: buildRoot({}, vatParameters, baggage), adminNode };
+  };
+  const createVatByName = async name => {
+    return createVat(fakeNameToCap.get(name) || Fail`unknown vat ${name}`);
+  };
+
+  const vatAdminService = Far('vatAdminSvc', {
+    ...fakeVatAdmin,
+    createVat,
+    createVatByName,
+  });
+  const criticalVatKey = vatAdminState.getCriticalVatKey();
+  const getCriticalVatKey = () => criticalVatKey;
+  const createVatAdminService = () => vatAdminService;
+  /** @type { any } */
+  const vatAdminRoot = { getCriticalVatKey, createVatAdminService };
+  return { vatAdminService, vatAdminRoot };
+};
+
+export const mockSwingsetVats = mock => {
+  const { vatAdminRoot } = makePopulatedFakeVatAdmin();
+  const vats = {
+    ...mock.vats,
+    vatAdmin: vatAdminRoot,
+  };
+  return vats;
+};
+
+/**
+ * @param {(msg: string) => void} log
+ */
+export const mockPsmBootstrapArgs = log => {
+  const mock = makeMock(log);
+  const vats = mockSwingsetVats(mock);
+  return [vats, mock.devices];
+};

package/tools/viz.mk

@@ -0,0 +1,17 @@
+# config: tools outsidet the source tree
+VIEWER=firefox
+DOT=dot
+
+CONFIG=decentral-test-vaults-config
+
+SRC=../src/core/chain-behaviors.js ../src/core/basic-behaviors.js
+
+$(CONFIG).svg: $(CONFIG).dot
+	$(DOT) -Tsvg $< >$@ || rm $@
+
+view: $(CONFIG).svg
+	$(VIEWER) $<
+
+$(CONFIG).dot: ../$(CONFIG).json $(SRC) authorityViz.js
+	node authorityViz.js ../$(CONFIG).json >$@ || rm $@
+