@agoric/vats 0.15.1 → 0.15.2-dev-8690eb0.0

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 $@
+