@agoric/vats 0.15.2-u11.0 → 0.15.2-u12.0

package/src/provisionPool.d.ts

@@ -27,7 +27,7 @@ export function prepare(zcf: ZCF<ProvisionTerms>, privateArgs: {
                 reviveWallet(address: string): Promise<{
                     handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string>, canSpend?: boolean | undefined): Promise<void>;
                     getDepositFacet(): {
-                        receive(payment: import("@endo/far").FarRef<Payment<AssetKind>, import("@endo/eventual-send").DataOnly<Payment<AssetKind>>>): Promise<Amount<AssetKind>>;
+                        receive(payment: Payment<AssetKind>): Promise<Amount<AssetKind>>;
                     };
                     getOffersFacet(): {
                         executeOffer(offerSpec: import("@agoric/smart-wallet/src/offers.js").OfferSpec): Promise<void>;
@@ -82,7 +82,7 @@ export function prepare(zcf: ZCF<ProvisionTerms>, privateArgs: {
                 reviveWallet(address: string): Promise<{
                     handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string>, canSpend?: boolean | undefined): Promise<void>;
                     getDepositFacet(): {
-                        receive(payment: import("@endo/far").FarRef<Payment<AssetKind>, import("@endo/eventual-send").DataOnly<Payment<AssetKind>>>): Promise<Amount<AssetKind>>;
+                        receive(payment: Payment<AssetKind>): Promise<Amount<AssetKind>>;
                     };
                     getOffersFacet(): {
                         executeOffer(offerSpec: import("@agoric/smart-wallet/src/offers.js").OfferSpec): Promise<void>;

package/src/provisionPoolKit.d.ts

@@ -22,7 +22,7 @@ export function prepareProvisionPoolKit(baggage: MapStore<string, unknown>, { ma
             reviveWallet(address: string): Promise<{
                 handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string>, canSpend?: boolean | undefined): Promise<void>;
                 getDepositFacet(): {
-                    receive(payment: import("@endo/far").FarRef<Payment<AssetKind>, import("@endo/eventual-send").DataOnly<Payment<AssetKind>>>): Promise<Amount<AssetKind>>;
+                    receive(payment: Payment<AssetKind>): Promise<Amount<AssetKind>>;
                 };
                 getOffersFacet(): {
                     executeOffer(offerSpec: import("@agoric/smart-wallet/src/offers.js").OfferSpec): Promise<void>;
@@ -69,7 +69,7 @@ export function prepareProvisionPoolKit(baggage: MapStore<string, unknown>, { ma
         reviveWallet(address: string): Promise<{
             handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string>, canSpend?: boolean | undefined): Promise<void>;
             getDepositFacet(): {
-                receive(payment: import("@endo/far").FarRef<Payment<AssetKind>, import("@endo/eventual-send").DataOnly<Payment<AssetKind>>>): Promise<Amount<AssetKind>>;
+                receive(payment: Payment<AssetKind>): Promise<Amount<AssetKind>>;
             };
             getOffersFacet(): {
                 executeOffer(offerSpec: import("@agoric/smart-wallet/src/offers.js").OfferSpec): Promise<void>;
@@ -136,7 +136,7 @@ export function prepareProvisionPoolKit(baggage: MapStore<string, unknown>, { ma
             reviveWallet(address: string): Promise<{
                 handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string>, canSpend?: boolean | undefined): Promise<void>;
                 getDepositFacet(): {
-                    receive(payment: import("@endo/far").FarRef<Payment<AssetKind>, import("@endo/eventual-send").DataOnly<Payment<AssetKind>>>): Promise<Amount<AssetKind>>;
+                    receive(payment: Payment<AssetKind>): Promise<Amount<AssetKind>>;
                 };
                 getOffersFacet(): {
                     executeOffer(offerSpec: import("@agoric/smart-wallet/src/offers.js").OfferSpec): Promise<void>;
@@ -183,7 +183,7 @@ export function prepareProvisionPoolKit(baggage: MapStore<string, unknown>, { ma
         reviveWallet(address: string): Promise<{
             handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string>, canSpend?: boolean | undefined): Promise<void>;
             getDepositFacet(): {
-                receive(payment: import("@endo/far").FarRef<Payment<AssetKind>, import("@endo/eventual-send").DataOnly<Payment<AssetKind>>>): Promise<Amount<AssetKind>>;
+                receive(payment: Payment<AssetKind>): Promise<Amount<AssetKind>>;
             };
             getOffersFacet(): {
                 executeOffer(offerSpec: import("@agoric/smart-wallet/src/offers.js").OfferSpec): Promise<void>;
@@ -324,7 +324,15 @@ export type PsmInstance = import('@agoric/zoe/src/zoeService/utils').Instance<(z
         getInvitationAmount: (name: string) => Amount<"set">;
         getNat: (name: string) => bigint;
         getRatio: (name: string) => Ratio;
-        getString: (name: string) => string;
+        getString: (name: string) => string; /**
+         * @param {import('@agoric/vat-data').Baggage} baggage
+         * @param {{
+         *   makeRecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit,
+         *   params: *,
+         *   poolBank: import('@endo/far').ERef<Bank>,
+         *   zcf: ZCF,
+         * }} powers
+         */
         getTimestamp: (name: string) => import("@agoric/time/src/types.js").TimestampRecord;
         getRelativeTime: (name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord;
         getUnknown: (name: string) => any;
@@ -345,7 +353,15 @@ export type PsmInstance = import('@agoric/zoe/src/zoeService/utils').Instance<(z
         getInvitationAmount: (name: string) => Amount<"set">;
         getNat: (name: string) => bigint;
         getRatio: (name: string) => Ratio;
-        getString: (name: string) => string;
+        getString: (name: string) => string; /**
+         * @param {import('@agoric/vat-data').Baggage} baggage
+         * @param {{
+         *   makeRecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit,
+         *   params: *,
+         *   poolBank: import('@endo/far').ERef<Bank>,
+         *   zcf: ZCF,
+         * }} powers
+         */
         getTimestamp: (name: string) => import("@agoric/time/src/types.js").TimestampRecord;
         getRelativeTime: (name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord;
         getUnknown: (name: string) => any;

package/src/provisionPoolKit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provisionPoolKit.d.ts","sourceRoot":"","sources":["provisionPoolKit.js"],"names":[],"mappings":"AAqDO,0EAJkB,KAAK,IAAI,CAAC,KAAK,QAAQ,IAAI,CAAC,iBAC1C,MAAM,IAAI,0DAKR,0BAA0B;;;;GAgCtC;AAWM,wHAPI;IACV,eAAmB,EAAE,OAAO,6CAA6C,EAAE,eAAe,CAAC;IAC3F,MAAU,MAAI;IACd,QAAY,EAAE,OAAO,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7C,GAAO,EAAE,GAAG,CAAC;CACV;IA8VqB,SAAS,EAArB,KAAK;IACmB,WAAW,EAAnC,KAAK,WAAW,CAAC;;;QAhRtB;;WAEG;4CADQ,MAAM,EAAE;;YAkDnB,8BAA8B;kCAAlB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;YAqBlB;;;eAGG;+BAFQ,MAAM,GACJ,OAAO;;QAhEpB;;WAEG;6BADQ,0BAA0B;;;;;;QA8BrC;;;WAGG;uBAFQ,KAAK,YACL,WAAW;;;QAQtB,8BAA8B;8BAAlB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;QAqBlB;;;WAGG;2BAFQ,MAAM,GACJ,OAAO;;;;;;;QAgDpB;;;WAGG;qCADQ,KAAK,IAAI,CAAC;QA2BrB;;;WAGG;;;;QA2EH;;;;WAIG;oBAHQ,KAAK,OAAO,CAAC,UACb,MAAM,YACN,WAAW;;;;;;;;;QAxOtB;;WAEG;4CADQ,MAAM,EAAE;;YAkDnB,8BAA8B;kCAAlB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;YAqBlB;;;eAGG;+BAFQ,MAAM,GACJ,OAAO;;QAhEpB;;WAEG;6BADQ,0BAA0B;;;;;;QA8BrC;;;WAGG;uBAFQ,KAAK,YACL,WAAW;;;QAQtB,8BAA8B;8BAAlB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;QAqBlB;;;WAGG;2BAFQ,MAAM,GACJ,OAAO;;;;;;;QAgDpB;;;WAGG;qCADQ,KAAK,IAAI,CAAC;QA2BrB;;;WAGG;;;;QA2EH;;;;WAIG;oBAHQ,KAAK,OAAO,CAAC,UACb,MAAM,YACN,WAAW;;;;;;;IAwD7B;0BAtba,OAAO,kCAAkC,EAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyD;;iBAI5G,KAAK,WAAW,CAAC;yBACjB,KAAK,OAAO,cAAc,EAAE,SAAS,CAAC;mBACtC,KAAK,OAAO,0CAA0C,EAAE,wBAAwB,CAAC,cAAc,CAAC,CAAC;;;;;;;;;;wBAQjG,MAAM;;;;yBACN,OAAO,KAAK,CAAC;;;;;0BACb,OAAO,KAAK,CAAC;;;;;;mBAUd,OAAO,eAAe,EAAE,IAAI"}
+{"version":3,"file":"provisionPoolKit.d.ts","sourceRoot":"","sources":["provisionPoolKit.js"],"names":[],"mappings":"AAqDO,0EAJkB,KAAK,IAAI,CAAC,KAAK,QAAQ,IAAI,CAAC,iBAC1C,MAAM,IAAI,0DAKR,0BAA0B;;;;GAgCtC;AAWM,wHAPI;IACV,eAAmB,EAAE,OAAO,6CAA6C,EAAE,eAAe,CAAC;IAC3F,MAAU,MAAI;IACd,QAAY,EAAE,OAAO,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7C,GAAO,EAAE,GAAG,CAAC;CACV;IA8VqB,SAAS,EAArB,KAAK;IACmB,WAAW,EAAnC,KAAK,WAAW,CAAC;;;QAhRtB;;WAEG;4CADQ,MAAM,EAAE;;YAkDnB,8BAA8B;kCAAlB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;YAqBlB;;;eAGG;+BAFQ,MAAM,GACJ,OAAO;;QAhEpB;;WAEG;6BADQ,0BAA0B;;;;;;QA8BrC;;;WAGG;uBAFQ,KAAK,YACL,WAAW;;;QAQtB,8BAA8B;8BAAlB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;QAqBlB;;;WAGG;2BAFQ,MAAM,GACJ,OAAO;;;;;;;QAgDpB;;;WAGG;qCADQ,KAAK,IAAI,CAAC;QA2BrB;;;WAGG;;;;QA2EH;;;;WAIG;oBAHQ,KAAK,OAAO,CAAC,UACb,MAAM,YACN,WAAW;;;;;;;;;QAxOtB;;WAEG;4CADQ,MAAM,EAAE;;YAkDnB,8BAA8B;kCAAlB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;YAqBlB;;;eAGG;+BAFQ,MAAM,GACJ,OAAO;;QAhEpB;;WAEG;6BADQ,0BAA0B;;;;;;QA8BrC;;;WAGG;uBAFQ,KAAK,YACL,WAAW;;;QAQtB,8BAA8B;8BAAlB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;QAqBlB;;;WAGG;2BAFQ,MAAM,GACJ,OAAO;;;;;;;QAgDpB;;;WAGG;qCADQ,KAAK,IAAI,CAAC;QA2BrB;;;WAGG;;;;QA2EH;;;;WAIG;oBAHQ,KAAK,OAAO,CAAC,UACb,MAAM,YACN,WAAW;;;;;;;IAwD7B;0BAtba,OAAO,kCAAkC,EAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAgEjE;;;;;;;;WAQG;;;;;;;;;;;;;;;;;;;;;6CARH;;;;;;;;WAQG;;;;;;;;;;;;;;GAxEuH;;iBAI5G,KAAK,WAAW,CAAC;yBACjB,KAAK,OAAO,cAAc,EAAE,SAAS,CAAC;mBACtC,KAAK,OAAO,0CAA0C,EAAE,wBAAwB,CAAC,cAAc,CAAC,CAAC;;;;;;;;;;wBAQjG,MAAM;;;;yBACN,OAAO,KAAK,CAAC;;;;;0BACb,OAAO,KAAK,CAAC;;;;;;mBAUd,OAAO,eAAe,EAAE,IAAI"}

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, -1);
+  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;
+};