@agoric/cosmic-swingset 0.41.4-dev-fe66674.0 → 0.41.4-dev-85bac81.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/cosmic-swingset",
-  "version": "0.41.4-dev-fe66674.0+fe66674",
+  "version": "0.41.4-dev-85bac81.0+85bac81",
   "description": "Agoric's Cosmos blockchain integration",
   "type": "module",
   "bin": {
@@ -22,18 +22,19 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/builders": "0.1.1-dev-fe66674.0+fe66674",
-    "@agoric/cosmos": "0.34.2-dev-fe66674.0+fe66674",
-    "@agoric/deploy-script-support": "0.10.4-dev-fe66674.0+fe66674",
-    "@agoric/internal": "0.3.3-dev-fe66674.0+fe66674",
-    "@agoric/store": "0.9.3-dev-fe66674.0+fe66674",
-    "@agoric/swing-store": "0.9.2-dev-fe66674.0+fe66674",
-    "@agoric/swingset-vat": "0.32.3-dev-fe66674.0+fe66674",
-    "@agoric/telemetry": "0.6.3-dev-fe66674.0+fe66674",
-    "@agoric/vm-config": "0.1.1-dev-fe66674.0+fe66674",
+    "@agoric/builders": "0.1.1-dev-85bac81.0+85bac81",
+    "@agoric/cosmos": "0.34.2-dev-85bac81.0+85bac81",
+    "@agoric/deploy-script-support": "0.10.4-dev-85bac81.0+85bac81",
+    "@agoric/internal": "0.3.3-dev-85bac81.0+85bac81",
+    "@agoric/store": "0.9.3-dev-85bac81.0+85bac81",
+    "@agoric/swing-store": "0.9.2-dev-85bac81.0+85bac81",
+    "@agoric/swingset-vat": "0.32.3-dev-85bac81.0+85bac81",
+    "@agoric/telemetry": "0.6.3-dev-85bac81.0+85bac81",
+    "@agoric/vm-config": "0.1.1-dev-85bac81.0+85bac81",
     "@endo/bundle-source": "^3.5.1",
     "@endo/env-options": "^1.1.8",
     "@endo/errors": "^1.2.9",
+    "@endo/eventual-send": "^1.3.0",
     "@endo/far": "^1.1.10",
     "@endo/import-bundle": "^1.3.3",
     "@endo/init": "^1.1.8",
@@ -47,6 +48,7 @@
     "anylogger": "^0.21.0",
     "deterministic-json": "^1.0.5",
     "import-meta-resolve": "^2.2.1",
+    "ses": "^1.11.0",
     "tmp": "^0.2.1"
   },
   "devDependencies": {
@@ -71,5 +73,5 @@
   "typeCoverage": {
     "atLeast": 83.4
   },
-  "gitHead": "fe666748e6b4ff8f8152eb77740fb6dd0cef5b83"
+  "gitHead": "85bac810ac4684978b3fac16cea9af04996cc9f1"
 }

package/src/chain-main.js

@@ -112,6 +112,28 @@ const validateSwingsetConfig = swingsetConfig => {
     Fail`maxVatsOnline must be a positive integer`;
 };
 
+/**
+ * Capture "port numbers" for communicating with cosmos modules.
+ *
+ * @param {object} action
+ */
+export const extractPortNums = action => {
+  const portNums = {};
+  for (const [key, value] of Object.entries(action)) {
+    const portAlias = CosmosInitKeyToBridgeId[key];
+    if (portAlias) {
+      // Use the alias if it exists.
+      portNums[portAlias] = value;
+    } else if (key.endsWith(PORT_SUFFIX)) {
+      // Anything else that ends in the suffix is assumed to be a port
+      // number, as described in app.go/cosmosInitAction.
+      const portName = key.slice(0, key.length - PORT_SUFFIX.length);
+      portNums[portName] = value;
+    }
+  }
+  return harden(portNums);
+};
+
 /**
  * @template {unknown} [T=unknown]
  * @param {(req: string) => string} call
@@ -174,88 +196,57 @@ const makePrefixedBridgeStorage = (
   });
 };
 
-export default async function main(
-  progname,
-  args,
-  { env, homedir, path = nativePath, agcc },
-) {
-  const portNums = {};
-
-  // TODO: use the 'basedir' pattern
-
-  const processValue = makeProcessValue({ env, args });
-
-  // We try to find the actual cosmos state directory (default=~/.ag-chain-cosmos), which
-  // is better than scribbling into the current directory.
-  const cosmosHome = processValue.getFlag(
-    'home',
-    `${homedir}/.ag-chain-cosmos`,
+/**
+ * @param {(req: string) => string} call
+ * @param {string} queuePath
+ */
+export const makeQueueStorage = (call, queuePath) => {
+  const { kvStore, commit, abort } = makeBufferedStorage(
+    makePrefixedBridgeStorage(
+      call,
+      `${queuePath}.`,
+      'setWithoutNotify',
+      x => x,
+      x => x,
+    ),
   );
-  const stateDBDir = `${cosmosHome}/data/agoric`;
-  fs.mkdirSync(stateDBDir, { recursive: true });
-
-  // console.log('Have AG_COSMOS', agcc);
-
-  const portHandlers = {};
-  let lastPort = 0;
-  function registerPortHandler(portHandler) {
-    lastPort += 1;
-    const port = lastPort;
-    portHandlers[port] = async (...phArgs) =>
-      E.resolve(portHandler(...phArgs)).catch(e => {
-        console.error('portHandler threw', e);
-        throw e;
-      });
-    return port;
-  }
-
-  function fromGo(port, str, replier) {
-    // console.error(`inbound ${port} ${str}`);
-    const handler = portHandlers[port];
-    if (!handler) {
-      replier.reject(`invalid requested port ${port}`);
-      return;
-    }
-    const action = JSON.parse(str);
-    const p = Promise.resolve(handler(action));
-    void E.when(
-      p,
-      res => {
-        // console.error(`Replying in Node to ${str} with`, res);
-        replier.resolve(stringify(res !== undefined ? res : null));
-      },
-      rej => {
-        // console.error(`Rejecting in Node to ${str} with`, rej);
-        replier.reject(`${(rej && rej.stack) || rej}`);
-      },
-    );
-  }
-
-  // Actually run the main ag-chain-cosmos program.  Before we start the daemon,
-  // there will be a call to nodePort/AG_COSMOS_INIT, otherwise exit.
-  const nodePort = registerPortHandler(toSwingSet);
-
-  // Need to keep the process alive until Go exits.
-  whenHellFreezesOver = new Promise(() => {});
-  agcc.runAgCosmosDaemon(nodePort, fromGo, [progname, ...args]);
-
-  /**
-   * @type {undefined | {
-   *   blockHeight: number,
-   *   exporter?: import('./export-kernel-db.js').StateSyncExporter,
-   *   exportDir?: string,
-   *   cleanup?: () => Promise<void>,
-   * }}
-   */
-  let stateSyncExport;
-
-  async function discardStateSyncExport() {
-    const exportData = stateSyncExport;
-    stateSyncExport = undefined;
-    await exportData?.exporter?.stop();
-    await exportData?.cleanup?.();
-  }
+  return harden({ ...kvStore, commit, abort });
+};
 
+/**
+ * @param {any} agcc
+ * @param {string} stateDBDir
+ * @param {object} options
+ * @param {typeof process.env} [options.env]
+ * @param {Pick<import('fs'), 'createWriteStream' | 'mkdirSync' | 'renameSync'>} options.fs
+ * @param {Pick<import('path'), 'join' | 'resolve'>} options.path
+ * @param {import('tmp')} [options.tmp] required to support vatSnapshotArchiveDir/vatTranscriptArchiveDir
+ * @param {ReturnType<typeof makeProcessValue>} [options.processValue]
+ * @param {() => Promise<void>} [options.readyForCommit]
+ * @param {{
+ *   debugName?: string,
+ *   slogSender?: ERef<EReturn<typeof makeSlogSender>>,
+ *   swingStore?: import('@agoric/swing-store').SwingStore,
+ *   vatconfig?: Parameters<typeof launch>[0]['vatconfig'],
+ * }} [options.testingOverrides]
+ */
+export const makeLaunchChain = (
+  agcc,
+  stateDBDir,
+  {
+    env = {},
+    // eslint-disable-next-line no-shadow
+    fs,
+    path,
+    // eslint-disable-next-line no-shadow
+    tmp,
+    processValue = makeProcessValue({ env, args: [] }),
+    readyForCommit,
+    testingOverrides = {},
+  },
+) => {
+  /** @typedef {[args: Parameters<typeof agcc.send>, ret: ReturnType<typeof agcc.send>]} SavedChainSend */
+  /** @type {SavedChainSend[]} */
   let savedChainSends = [];
 
   // Send a chain downcall, recording what we sent and received.
@@ -266,8 +257,10 @@ export default async function main(
   }
 
   const clearChainSends = async () => {
-    // Cosmos should have blocked before calling commit, but wait just in case
-    await stateSyncExport?.exporter?.onStarted().catch(ignore);
+    // TODO: Make `readyForCommit` an explicit `launch` input rather than
+    // having an overloaded async `clearChainSends` with the expectation that
+    // it is called right before `commit()`.
+    await readyForCommit?.();
 
     const chainSends = savedChainSends;
     savedChainSends = [];
@@ -282,7 +275,9 @@ export default async function main(
 
     // Just send all the things we saved.
     while (chainSends.length > 0) {
-      const [sendArgs, expectedRet] = chainSends.shift();
+      const [sendArgs, expectedRet] = /** @type {SavedChainSend} */ (
+        chainSends.shift()
+      );
       const actualRet = agcc.send(...sendArgs);
 
       // Enforce that we got back what we expected.
@@ -296,14 +291,9 @@ export default async function main(
     }
   }
 
-  /** @type {((obj: object) => void) | undefined} */
-  let writeSlogObject;
-
-  // In the past, storagePort could change with every message. It's defined out
-  // here so 'sendToChainStorage' can close over the single mutable instance,
-  // when we updated the 'portNums.storage' value each time toSwingSet was called.
-  async function launchAndInitializeSwingSet(initAction) {
-    const { XSNAP_KEEP_SNAPSHOTS, NODE_HEAP_SNAPSHOTS = -1 } = env;
+  const launchChain = async initAction => {
+    const { XSNAP_KEEP_SNAPSHOTS = '', NODE_HEAP_SNAPSHOTS = '-1' } = env;
+    const portNums = extractPortNums(initAction);
 
     /** @type {CosmosSwingsetConfig} */
     const swingsetConfig = harden(initAction.resolvedConfig || {});
@@ -342,20 +332,12 @@ export default async function main(
         val => stringify(exportMailbox(val)),
       ),
     );
-    const makeQueueStorage = queuePath => {
-      const { kvStore, commit, abort } = makeBufferedStorage(
-        makePrefixedBridgeStorage(
-          sendToChainStorage,
-          `${queuePath}.`,
-          'setWithoutNotify',
-          x => x,
-          x => x,
-        ),
-      );
-      return harden({ ...kvStore, commit, abort });
-    };
-    const actionQueueStorage = makeQueueStorage(STORAGE_PATH.ACTION_QUEUE);
+    const actionQueueStorage = makeQueueStorage(
+      sendToChainStorage,
+      STORAGE_PATH.ACTION_QUEUE,
+    );
     const highPriorityQueueStorage = makeQueueStorage(
+      sendToChainStorage,
       STORAGE_PATH.HIGH_PRIORITY_QUEUE,
     );
     /**
@@ -451,20 +433,18 @@ export default async function main(
       return pathname;
     };
 
-    // Delay makeShutdown to override the golang interrupts
-    const { registerShutdown } = makeShutdown();
-
     const { metricsProvider } = getTelemetryProviders({
       console,
       env,
       serviceName: TELEMETRY_SERVICE_NAME,
     });
 
-    const slogSender = await makeSlogSender({
-      stateDir: stateDBDir,
-      env,
-      serviceName: TELEMETRY_SERVICE_NAME,
-    });
+    const slogSender = await (testingOverrides.slogSender ||
+      makeSlogSender({
+        stateDir: stateDBDir,
+        env,
+        serviceName: TELEMETRY_SERVICE_NAME,
+      }));
 
     const swingStoreTraceFile = processValue.getPath({
       envName: 'SWING_STORE_TRACE',
@@ -546,19 +526,23 @@ export default async function main(
     const s = await launch({
       actionQueueStorage,
       highPriorityQueueStorage,
-      kernelStateDBDir: stateDBDir,
+      swingStore: testingOverrides.swingStore,
+      kernelStateDBDir: testingOverrides.swingStore ? undefined : stateDBDir,
       makeInstallationPublisher,
       mailboxStorage,
       clearChainSends,
       replayChainSends,
       bridgeOutbound: doOutboundBridge,
-      vatconfig: getVatConfig,
+      vatconfig: testingOverrides.vatconfig || getVatConfig,
       argv,
       env,
       verboseBlocks: true,
       metricsProvider,
+      debugName: testingOverrides.debugName,
       slogSender,
-      swingStoreExportCallback,
+      swingStoreExportCallback: testingOverrides.swingStore
+        ? undefined
+        : swingStoreExportCallback,
       swingStoreTraceFile,
       keepSnapshots,
       keepTranscripts,
@@ -567,30 +551,94 @@ export default async function main(
       afterCommitCallback,
       swingsetConfig,
     });
+    savedChainSends = s.savedChainSends;
+    return s;
+  };
 
-    const { blockingSend, shutdown } = s;
-    ({ writeSlogObject, savedChainSends } = s);
+  return launchChain;
+};
 
-    let pendingBlockingSend = Promise.resolve();
+export default async function main(
+  progname,
+  args,
+  { env, homedir, path = nativePath, agcc },
+) {
+  // TODO: use the 'basedir' pattern
 
-    registerShutdown(async interrupted => {
-      await Promise.all([
-        interrupted && pendingBlockingSend.then(shutdown),
-        discardStateSyncExport(),
-      ]);
-    });
+  const processValue = makeProcessValue({ env, args });
 
-    const blockingSendSpy = async action => {
-      const result = blockingSend(action);
-      pendingBlockingSend = Promise.resolve(result).then(ignore, ignore);
-      return result;
-    };
-    return blockingSendSpy;
-  }
+  // We try to find the actual cosmos state directory (default=~/.ag-chain-cosmos), which
+  // is better than scribbling into the current directory.
+  const cosmosHome = processValue.getFlag(
+    'home',
+    `${homedir}/.ag-chain-cosmos`,
+  );
+  const stateDBDir = `${cosmosHome}/data/agoric`;
+  fs.mkdirSync(stateDBDir, { recursive: true });
 
   /** @type {EReturn<typeof launch>['blockingSend'] | undefined} */
   let blockingSend;
 
+  const portHandlers = {};
+  let lastPort = 0;
+  function registerPortHandler(portHandler) {
+    lastPort += 1;
+    const port = lastPort;
+    portHandlers[port] = async (...phArgs) =>
+      E.resolve(portHandler(...phArgs)).catch(e => {
+        console.error('portHandler threw', e);
+        throw e;
+      });
+    return port;
+  }
+
+  function fromGo(port, str, replier) {
+    // console.error(`inbound ${port} ${str}`);
+    const handler = portHandlers[port];
+    if (!handler) {
+      replier.reject(`invalid requested port ${port}`);
+      return;
+    }
+    const action = JSON.parse(str);
+    const p = Promise.resolve(handler(action));
+    void E.when(
+      p,
+      res => {
+        // console.error(`Replying in Node to ${str} with`, res);
+        replier.resolve(stringify(res !== undefined ? res : null));
+      },
+      rej => {
+        // console.error(`Rejecting in Node to ${str} with`, rej);
+        replier.reject(`${(rej && rej.stack) || rej}`);
+      },
+    );
+  }
+
+  // Actually run the main ag-chain-cosmos program.  Before we start the daemon,
+  // there will be a call to nodePort/AG_COSMOS_INIT, otherwise exit.
+  const nodePort = registerPortHandler(toSwingSet);
+
+  // Need to keep the process alive until Go exits.
+  whenHellFreezesOver = new Promise(() => {});
+  agcc.runAgCosmosDaemon(nodePort, fromGo, [progname, ...args]);
+
+  /**
+   * @type {undefined | {
+   *   blockHeight: number,
+   *   exporter?: import('./export-kernel-db.js').StateSyncExporter,
+   *   exportDir?: string,
+   *   cleanup?: () => Promise<void>,
+   * }}
+   */
+  let stateSyncExport;
+
+  async function discardStateSyncExport() {
+    const exportData = stateSyncExport;
+    stateSyncExport = undefined;
+    await exportData?.exporter?.stop();
+    await exportData?.cleanup?.();
+  }
+
   async function handleSwingStoreExport(blockHeight, request, requestArgs) {
     await null;
     switch (request) {
@@ -729,6 +777,19 @@ export default async function main(
     }
   }
 
+  const launchChain = makeLaunchChain(agcc, stateDBDir, {
+    env,
+    fs,
+    path,
+    tmp,
+    processValue,
+    readyForCommit: async () =>
+      stateSyncExport?.exporter?.onStarted().then(ignore, ignore),
+  });
+
+  /** @type {((obj: object) => void) | undefined} */
+  let writeSlogObject;
+
   async function toSwingSet(action, _replier) {
     // console.log(`toSwingSet`, action);
 
@@ -736,27 +797,27 @@ export default async function main(
 
     switch (action.type) {
       case ActionType.AG_COSMOS_INIT: {
-        // console.error('got AG_COSMOS_INIT', action);
-
         !blockingSend || Fail`Swingset already initialized`;
 
-        // Capture "port numbers" for communicating with cosmos modules.
-        for (const [key, value] of Object.entries(action)) {
-          const portAlias = CosmosInitKeyToBridgeId[key];
-          if (portAlias) {
-            // Use the alias if it exists.
-            portNums[portAlias] = value;
-          } else if (key.endsWith(PORT_SUFFIX)) {
-            // Anything else that ends in the suffix is assumed to be a port
-            // number, as described in app.go/cosmosInitAction.
-            const portName = key.slice(0, key.length - PORT_SUFFIX.length);
-            portNums[portName] = value;
-          }
-        }
-        harden(portNums);
-
-        // Ensure that initialization has completed.
-        blockingSend = await launchAndInitializeSwingSet(action);
+        const s = await launchChain(action);
+        const { blockingSend: sendToSwingset, shutdown } = s;
+        ({ writeSlogObject } = s);
+
+        // Wrap `blockingSend` with a spy for supporting clean shutdowns.
+        const { registerShutdown } = makeShutdown();
+        let pendingBlockingSend = Promise.resolve();
+        registerShutdown(async interrupted => {
+          await Promise.all([
+            interrupted && pendingBlockingSend.then(shutdown),
+            discardStateSyncExport(),
+          ]);
+        });
+        // eslint-disable-next-line no-shadow
+        blockingSend = async action => {
+          const result = sendToSwingset(action);
+          pendingBlockingSend = Promise.resolve(result).then(ignore, ignore);
+          return result;
+        };
 
         return blockingSend(action);
       }

package/src/export-kernel-db.js

@@ -2,7 +2,8 @@
 // @ts-check
 // @jessie-check
 
-import '@endo/init/unsafe-fast.js';
+// This file functions as both an importable module and a standalone script.
+import './helpers/maybe-unsafe-lockdown.js';
 
 import os from 'os';
 import process from 'process';

package/src/helpers/maybe-unsafe-lockdown.js

@@ -0,0 +1,8 @@
+import 'ses';
+import '@endo/eventual-send/shim.js';
+
+try {
+  lockdown({ __hardenTaming__: 'unsafe' });
+} catch (_err) {
+  // ignore
+}

package/src/import-kernel-db.js

@@ -2,7 +2,8 @@
 // @ts-check
 // @jessie-check
 
-import '@endo/init/unsafe-fast.js';
+// This file functions as both an importable module and a standalone script.
+import './helpers/maybe-unsafe-lockdown.js';
 
 import os from 'os';
 import process from 'process';

package/tools/test-kit.js

@@ -1,27 +1,30 @@
 /* eslint-env node */
 
+import fs from 'node:fs';
 import * as fsPromises from 'node:fs/promises';
-import * as pathNamespace from 'node:path';
+import nativePath from 'node:path';
+
+import tmp from 'tmp';
 import { Fail } from '@endo/errors';
+
 import {
   SwingsetMessageType,
   QueuedActionType,
 } from '@agoric/internal/src/action-types.js';
-import { makeInitMsg } from '@agoric/internal/src/chain-utils.js';
+import * as STORAGE_PATH from '@agoric/internal/src/chain-storage-paths.js';
 import { deepCopyJsonable } from '@agoric/internal/src/js-utils.js';
 import { initSwingStore } from '@agoric/swing-store';
-import { makeSlogSender } from '@agoric/telemetry';
-import { launch } from '../src/launch-chain.js';
-import { DEFAULT_SIM_SWINGSET_PARAMS } from '../src/sim-params.js';
+
 import {
-  makeBufferedStorage,
-  makeKVStoreFromMap,
-} from '../src/helpers/bufferedStorage.js';
-import { makeQueue, makeQueueStorageMock } from '../src/helpers/make-queue.js';
+  extractPortNums,
+  makeLaunchChain,
+  makeQueueStorage,
+} from '../src/chain-main.js';
+import { DEFAULT_SIM_SWINGSET_PARAMS } from '../src/sim-params.js';
+import { makeQueue } from '../src/helpers/make-queue.js';
 
 /** @import { BlockInfo, InitMsg } from '@agoric/internal/src/chain-utils.js' */
-/** @import { Mailbox, ManagerType, SwingSetConfig } from '@agoric/swingset-vat' */
-/** @import { KVStore } from '../src/helpers/bufferedStorage.js' */
+/** @import { ManagerType, SwingSetConfig } from '@agoric/swingset-vat' */
 /** @import { InboundQueue } from '../src/launch-chain.js'; */
 
 /**
@@ -36,30 +39,28 @@ const stripUndefined = obj =>
   );
 
 /** @type {InitMsg} */
-export const defaultInitMessage = harden(
-  makeInitMsg({
-    type: SwingsetMessageType.AG_COSMOS_INIT,
-    blockHeight: 100,
-    blockTime: Math.floor(Date.parse('2020-01-01T00:00Z') / 1000),
-    chainID: 'localtest',
-    params: DEFAULT_SIM_SWINGSET_PARAMS,
-    supplyCoins: [],
+export const defaultInitMessage = harden({
+  type: SwingsetMessageType.AG_COSMOS_INIT,
+  blockHeight: 100,
+  blockTime: Math.floor(Date.parse('2020-01-01T00:00Z') / 1000),
+  chainID: 'localtest',
+  params: DEFAULT_SIM_SWINGSET_PARAMS,
+  supplyCoins: [],
 
-    // cosmos-sdk module port mappings are generally ignored in testing, but
-    // relevant in live blockchains.
-    // Include them with unpredictable values.
-    ...Object.fromEntries(
-      Object.entries({
-        storagePort: 0,
-        swingsetPort: 0,
-        vbankPort: 0,
-        vibcPort: 0,
-      })
-        .sort(() => Math.random() - 0.5)
-        .map(([name, _zero], i) => [name, i + 1]),
-    ),
-  }),
-);
+  // cosmos-sdk module port mappings are generally ignored in testing, but
+  // relevant in live blockchains.
+  // Include them with unpredictable values.
+  ...Object.fromEntries(
+    Object.entries({
+      storagePort: 0,
+      swingsetPort: 0,
+      vbankPort: 0,
+      vibcPort: 0,
+    })
+      .sort(() => Math.random() - 0.5)
+      .map(([name, _zero], i) => [name, i + 1]),
+  ),
+});
 /** @type {InitMsg} */
 export const defaultBootstrapMessage = harden({
   ...deepCopyJsonable(defaultInitMessage),
@@ -170,7 +171,7 @@ export const makeCosmicSwingsetTestKit = async (
     fixupInitMessage,
     fixupConfig,
     slogSender,
-    swingsetConfig = {},
+    swingsetConfig,
     swingStore,
     vats,
 
@@ -179,7 +180,7 @@ export const makeCosmicSwingsetTestKit = async (
     addBootstrapBehaviors,
     bootstrapCoreEvals,
   } = {},
-  { fsp = fsPromises, resolvePath = pathNamespace.resolve } = {},
+  { fsp = fsPromises, resolvePath = nativePath.resolve } = {},
 ) => {
   await null;
   /** @type {SwingSetConfig} */
@@ -216,42 +217,46 @@ export const makeCosmicSwingsetTestKit = async (
   if (initMessage.isBootstrap === undefined && !swingStore) {
     initMessage.isBootstrap = true;
   }
+  const portNums = extractPortNums(initMessage);
+  const knownPorts = new Map(
+    Object.entries(portNums).map(([name, value]) => [value, name]),
+  );
 
   if (!swingStore) swingStore = initSwingStore(); // in-memory
   const { hostStorage } = swingStore;
 
-  const actionQueueStorage = makeQueueStorageMock().storage;
-  const highPriorityQueueStorage = makeQueueStorageMock().storage;
-  const { kvStore: mailboxKVStore, ...mailboxBufferMethods } =
-    makeBufferedStorage(
-      /** @type {KVStore<Mailbox>} */ (makeKVStoreFromMap(new Map())),
-    );
-  const mailboxStorage = { ...mailboxKVStore, ...mailboxBufferMethods };
-
-  const savedChainSends = [];
-  const clearChainSends = async () => savedChainSends.splice(0);
-  const replayChainSends = (..._args) => {
-    throw Error('not implemented');
+  const fakeAgcc = {
+    /** @type {(destPort: unknown, msgJson: string) => string} */
+    send: (destPort, msgJson) => {
+      const portName =
+        knownPorts.get(destPort) || Fail`unknown cosmos port ${destPort}`;
+      const msg = JSON.parse(msgJson);
+      const result = receiveBridgeSend(portName, msg);
+      return JSON.stringify(result);
+    },
   };
+  const actionQueueStorage = makeQueueStorage(
+    msg => fakeAgcc.send(portNums.storage, msg),
+    STORAGE_PATH.ACTION_QUEUE,
+  );
+  const highPriorityQueueStorage = makeQueueStorage(
+    msg => fakeAgcc.send(portNums.storage, msg),
+    STORAGE_PATH.HIGH_PRIORITY_QUEUE,
+  );
 
-  if (!slogSender && (env.SLOGFILE || env.SLOGSENDER)) {
-    slogSender = await makeSlogSender({ env });
-  }
-
-  const launchResult = await launch({
-    swingStore,
-    actionQueueStorage,
-    highPriorityQueueStorage,
-    mailboxStorage,
-    clearChainSends,
-    replayChainSends,
-    bridgeOutbound: receiveBridgeSend,
-    vatconfig: config,
-    argv: { bootMsg: initMessage },
+  const { name: dbDir, removeCallback: cleanupDB } = tmp.dirSync({
+    prefix: debugName || 'testdb',
+    unsafeCleanup: true,
+  });
+  const launchChain = makeLaunchChain(fakeAgcc, dbDir, {
     env,
-    debugName,
-    slogSender,
-    swingsetConfig,
+    fs,
+    path: nativePath,
+    testingOverrides: { debugName, slogSender, swingStore, vatconfig: config },
+  });
+  const launchResult = await launchChain({
+    ...initMessage,
+    resolvedConfig: swingsetConfig,
   });
   const { blockingSend, shutdown: shutdownKernel } = launchResult;
   /** @type {(options?: { kernelOnly?: boolean }) => Promise<void>} */
@@ -259,6 +264,7 @@ export const makeCosmicSwingsetTestKit = async (
     await shutdownKernel();
     if (kernelOnly) return;
     await hostStorage.close();
+    await cleanupDB();
   };
 
   // Remember information about the current block, starting with the init
@@ -379,7 +385,6 @@ export const makeCosmicSwingsetTestKit = async (
     // SwingSet-oriented references.
     actionQueue,
     highPriorityQueue,
-    mailboxStorage,
     shutdown,
     swingStore,