diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/init-old-vaultFactory.js b/packages/vats/test/bootstrapTests/liquidationVisibility/init-old-vaultFactory.js
deleted file mode 100644
index 3a5b3e98d6a..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/init-old-vaultFactory.js
+++ /dev/null
@@ -1,203 +0,0 @@
-/* global process */
-/**
- * @file can be run with `agoric deploy` after a chain is running (depends on chain state)
- * Only works with "local" chain and not sim-chain b/c it needs governance votes (n/a on sim-chain).
- */
-import { makeHelpers } from '@agoric/deploy-script-support';
-import { objectMap } from '@agoric/internal';
-
-import {
-  getManifestForInterProtocol,
-  getManifestForEconCommittee,
-  getManifestForMain,
-} from '@agoric/inter-protocol/src/proposals/core-proposal.js';
-import { makeInstallCache } from '@agoric/inter-protocol/src/proposals/utils.js';
-
-/** @type {Record<string, Record<string, [string, string]>>} */
-const installKeyGroups = {
-  econCommittee: {
-    contractGovernor: [
-      '@agoric/governance/src/contractGovernor.js',
-      '../../../../governance/bundles/bundle-contractGovernor.js',
-    ],
-    committee: [
-      '@agoric/governance/src/committee.js',
-      '../../../../governance/bundles/bundle-committee.js',
-    ],
-    binaryVoteCounter: [
-      '@agoric/governance/src/binaryVoteCounter.js',
-      '../../../../governance/bundles/bundle-binaryVoteCounter.js',
-    ],
-  },
-  main: {
-    auctioneer: [
-      '@agoric/inter-protocol/src/auction/auctioneer.js',
-      '../../../../inter-protocol/bundles/bundle-auctioneer.js',
-    ],
-    vaultFactory: [
-      '@agoric/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultFactory.js',
-      '@agoric/vats/test/bootstrapTests/liquidationVisibility/bundles/bundle-vaultFactory.js',
-    ],
-    feeDistributor: [
-      '@agoric/inter-protocol/src/feeDistributor.js',
-      '../../../../inter-protocol/bundles/bundle-feeDistributor.js',
-    ],
-    reserve: [
-      '@agoric/inter-protocol/src/reserve/assetReserve.js',
-      '../../../../inter-protocol/bundles/bundle-reserve.js',
-    ],
-  },
-};
-
-/**
- * @param {object} opts
- * @param {(i: I) => R} opts.publishRef
- * @param {(m: string, b: string, opts?: any) => I} opts.install
- * @param {<T>(f: T) => T} [opts.wrapInstall]
- *
- * @param {object} [options]
- * @param {{ committeeName?: string, committeeSize?: number}} [options.econCommitteeOptions]
- * @template I
- * @template R
- */
-export const committeeProposalBuilder = async (
-  { publishRef, install: install0, wrapInstall },
-  { econCommitteeOptions } = {},
-) => {
-  const install = wrapInstall ? wrapInstall(install0) : install0;
-
-  /** @param {Record<string, [string, string]>} group */
-  const publishGroup = group =>
-    objectMap(group, ([mod, bundle]) =>
-      publishRef(install(mod, bundle, { persist: true })),
-    );
-  return harden({
-    sourceSpec: '@agoric/inter-protocol/src/proposals/core-proposal.js',
-    getManifestCall: [
-      getManifestForEconCommittee.name,
-      {
-        econCommitteeOptions,
-        installKeys: {
-          ...publishGroup(installKeyGroups.econCommittee),
-        },
-      },
-    ],
-  });
-};
-
-/**
- * @param {object} opts
- * @param {(i: I) => R} opts.publishRef
- * @param {(m: string, b: string, opts?: any) => I} opts.install
- * @param {<T>(f: T) => T} [opts.wrapInstall]
- *
- * @template I
- * @template R
- */
-export const mainProposalBuilder = async ({
-  publishRef,
-  install: install0,
-  wrapInstall,
-}) => {
-  const { VAULT_FACTORY_CONTROLLER_ADDR } = process.env;
-
-  const install = wrapInstall ? wrapInstall(install0) : install0;
-
-  const persist = true;
-  /** @param {Record<string, [string, string]>} group */
-  const publishGroup = group =>
-    objectMap(group, ([mod, bundle]) =>
-      publishRef(install(mod, bundle, { persist })),
-    );
-  return harden({
-    sourceSpec: '@agoric/inter-protocol/src/proposals/core-proposal.js',
-    getManifestCall: [
-      getManifestForMain.name,
-      {
-        vaultFactoryControllerAddress: VAULT_FACTORY_CONTROLLER_ADDR,
-        installKeys: {
-          ...publishGroup(installKeyGroups.main),
-        },
-      },
-    ],
-  });
-};
-
-// Build proposal for sim-chain etc.
-/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').ProposalBuilder} */
-export const defaultProposalBuilder = async (
-  { publishRef, install },
-  options = {},
-  { env = process.env } = {},
-) => {
-  /** @param {string|undefined} s */
-  const optBigInt = s => s && BigInt(s);
-  const {
-    vaultFactoryControllerAddress = env.VAULT_FACTORY_CONTROLLER_ADDR,
-    minInitialPoolLiquidity = env.MIN_INITIAL_POOL_LIQUIDITY,
-    referencedUi,
-    anchorOptions: {
-      anchorDenom = env.ANCHOR_DENOM,
-      anchorDecimalPlaces = '6',
-      anchorKeyword = 'AUSD',
-      anchorProposedName = anchorKeyword,
-      initialPrice = undefined,
-    } = {},
-    econCommitteeOptions: {
-      committeeSize: econCommitteeSize = env.ECON_COMMITTEE_SIZE || '3',
-    } = {},
-  } = options;
-
-  /** @param {Record<string, [string, string]>} group */
-  const publishGroup = group =>
-    objectMap(group, ([mod, bundle]) => publishRef(install(mod, bundle)));
-
-  const anchorOptions = anchorDenom && {
-    denom: anchorDenom,
-    decimalPlaces: parseInt(anchorDecimalPlaces, 10),
-    initialPrice,
-    keyword: anchorKeyword,
-    proposedName: anchorProposedName,
-  };
-
-  const econCommitteeOptions = {
-    committeeSize: parseInt(econCommitteeSize, 10),
-  };
-
-  return harden({
-    sourceSpec: '@agoric/inter-protocol/src/proposals/core-proposal.js',
-    getManifestCall: [
-      getManifestForInterProtocol.name,
-      {
-        vaultFactoryControllerAddress,
-        minInitialPoolLiquidity: optBigInt(minInitialPoolLiquidity),
-        referencedUi,
-        anchorOptions,
-        econCommitteeOptions,
-        installKeys: {
-          ...publishGroup(installKeyGroups.econCommittee),
-          ...publishGroup(installKeyGroups.main),
-        },
-      },
-    ],
-  });
-};
-
-export default async (homeP, endowments) => {
-  const { writeCoreProposal } = await makeHelpers(homeP, endowments);
-
-  const tool = await makeInstallCache(homeP, {
-    loadBundle: spec => import(spec),
-  });
-  await Promise.all([
-    writeCoreProposal('gov-econ-committee', opts =>
-      // @ts-expect-error XXX makeInstallCache types
-      committeeProposalBuilder({ ...opts, wrapInstall: tool.wrapInstall }),
-    ),
-    writeCoreProposal('gov-amm-vaults-etc', opts =>
-      // @ts-expect-error XXX makeInstallCache types
-      mainProposalBuilder({ ...opts, wrapInstall: tool.wrapInstall }),
-    ),
-  ]);
-  await tool.saveCache();
-};
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/liquidation-test-utils.js b/packages/vats/test/bootstrapTests/liquidationVisibility/liquidation-test-utils.js
index b3b49404241..4dce762fd7c 100644
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/liquidation-test-utils.js
+++ b/packages/vats/test/bootstrapTests/liquidationVisibility/liquidation-test-utils.js
@@ -3,29 +3,10 @@
 /**
  * @file Bootstrap test vaults liquidation visibility
  */
-import * as processAmbient from 'child_process';
-import * as fsAmbient from 'fs';
-import { Fail, NonNullish } from '@agoric/assert';
+import { NonNullish } from '@agoric/assert';
 import { Offers } from '@agoric/inter-protocol/src/clientSupport.js';
 import { TimeMath } from '@agoric/time';
-import { eventLoopIteration } from '@agoric/internal/src/testing-utils.js';
-import {
-  SECONDS_PER_HOUR,
-  SECONDS_PER_MINUTE,
-} from '@agoric/inter-protocol/src/proposals/econ-behaviors.js';
 import { scale6 } from '../liquidation.js';
-import { makeAgoricNamesRemotesFromFakeStorage } from '../../../tools/board-utils.js';
-import { makeSwingsetTestKit } from '../supports.js';
-import {
-  makeGovernanceDriver,
-  makePriceFeedDriver,
-  makeWalletFactoryDriver,
-} from '../drivers.js';
-
-const PLATFORM_CONFIG =
-  '@agoric/vats/test/bootstrapTests/liquidationVisibility/vaults-liquidation-config.json';
-
-const DebtLimitValue = scale6(100_000);
 
 //#region Product spec
 const setup = /** @type {const} */ ({
@@ -265,299 +246,3 @@ export const checkVisibility = async ({
   t.log('postAuction', postAuction);
   t.log('auctionResult', auctionResult);
 };
-
-export const checkVMChildNodes = async ({
-  t,
-  managerIndex,
-  collateralBrandKey,
-  liquidation,
-  base = 0,
-}) => {
-  const { storage, advanceTimeBy, runUtils } = t.context;
-
-  await addNewVaults({ t, collateralBrandKey, base });
-  await runAuction(runUtils, advanceTimeBy);
-
-  const managerPath = `published.vaultFactory.managers.manager${managerIndex}`;
-  const childNodes = storage.toStorage({
-    method: 'children',
-    args: [`${managerPath}`],
-  });
-  t.log('VaultManager child nodes: ', childNodes);
-
-  let expectedChildNodes = ['governance', 'metrics', 'quotes', 'vaults'];
-  if (liquidation) {
-    expectedChildNodes = [...expectedChildNodes, 'liquidations'];
-  }
-
-  t.deepEqual(childNodes, expectedChildNodes);
-};
-
-/**
- * @param {object} powers
- * @param {Pick<typeof import('node:child_process'), 'execFileSync' >} powers.childProcess
- * @param {typeof import('node:fs/promises')} powers.fs
- */
-const makeProposalExtractor = ({ childProcess, fs }) => {
-  const getPkgPath = (pkg, fileName = '') =>
-    new URL(`../../../../${pkg}/${fileName}`, import.meta.url).pathname;
-
-  const runPackageScript = async (pkg, name, env) => {
-    console.warn(pkg, 'running package script:', name);
-    const pkgPath = getPkgPath(pkg);
-    return childProcess.execFileSync('yarn', ['run', name], {
-      cwd: pkgPath,
-      env,
-    });
-  };
-
-  const loadJSON = async filePath =>
-    harden(JSON.parse(await fs.readFile(filePath, 'utf8')));
-
-  // XXX parses the output to find the files but could write them to a path that can be traversed
-  /** @param {string} txt */
-  const parseProposalParts = txt => {
-    const evals = [
-      ...txt.matchAll(/swingset-core-eval (?<permit>\S+) (?<script>\S+)/g),
-    ].map(m => {
-      if (!m.groups) throw Fail`Invalid proposal output ${m[0]}`;
-      const { permit, script } = m.groups;
-      return { permit, script };
-    });
-    evals.length ||
-      Fail`No swingset-core-eval found in proposal output: ${txt}`;
-
-    const bundles = [
-      ...txt.matchAll(/swingset install-bundle @([^\n]+)/gm),
-    ].map(([, bundle]) => bundle);
-    bundles.length || Fail`No bundles found in proposal output: ${txt}`;
-
-    return { evals, bundles };
-  };
-
-  /**
-   * @param {object} options
-   * @param {string} options.package
-   * @param {string} options.packageScriptName
-   * @param {Record<string, string>} [options.env]
-   */
-  const buildAndExtract = async ({
-    package: packageName,
-    packageScriptName,
-    env = {},
-  }) => {
-    // eslint-disable-next-line no-undef
-    const scriptEnv = Object.assign(Object.create(process.env), env);
-    // XXX use '@agoric/inter-protocol'?
-    const out = await runPackageScript(
-      packageName,
-      packageScriptName,
-      scriptEnv,
-    );
-    const built = parseProposalParts(out.toString());
-
-    const loadAndRmPkgFile = async fileName => {
-      const filePath = getPkgPath(packageName, fileName);
-      const content = await fs.readFile(filePath, 'utf8');
-      await fs.rm(filePath);
-      return content;
-    };
-
-    const evalsP = Promise.all(
-      built.evals.map(async ({ permit, script }) => {
-        const [permits, code] = await Promise.all([
-          loadAndRmPkgFile(permit),
-          loadAndRmPkgFile(script),
-        ]);
-        return { json_permits: permits, js_code: code };
-      }),
-    );
-
-    const bundlesP = Promise.all(
-      built.bundles.map(
-        async bundleFile =>
-          /** @type {Promise<EndoZipBase64Bundle>} */ (loadJSON(bundleFile)),
-      ),
-    );
-    return Promise.all([evalsP, bundlesP]).then(([evals, bundles]) => ({
-      evals,
-      bundles,
-    }));
-  };
-  return buildAndExtract;
-};
-
-export const makeTestContext = async t => {
-  console.time('DefaultTestContext');
-  const swingsetTestKit = await makeSwingsetTestKit(t, 'bundles/vaults', {
-    configSpecifier: PLATFORM_CONFIG,
-  });
-
-  const { runUtils, storage } = swingsetTestKit;
-  console.timeLog('DefaultTestContext', 'swingsetTestKit');
-  const { EV } = runUtils;
-
-  // Wait for ATOM to make it into agoricNames
-  await EV.vat('bootstrap').consumeItem('vaultFactoryKit');
-  console.timeLog('DefaultTestContext', 'vaultFactoryKit');
-
-  await eventLoopIteration();
-
-  // has to be late enough for agoricNames data to have been published
-  const agoricNamesRemotes = makeAgoricNamesRemotesFromFakeStorage(
-    swingsetTestKit.storage,
-  );
-  agoricNamesRemotes.brand.ATOM || Fail`ATOM brand not yet defined`;
-  console.timeLog('DefaultTestContext', 'agoricNamesRemotes');
-
-  const walletFactoryDriver = await makeWalletFactoryDriver(
-    runUtils,
-    storage,
-    agoricNamesRemotes,
-  );
-  console.timeLog('DefaultTestContext', 'walletFactoryDriver');
-
-  const governanceDriver = await makeGovernanceDriver(
-    swingsetTestKit,
-    agoricNamesRemotes,
-    walletFactoryDriver,
-    // TODO read from the config file
-    [
-      'agoric1gx9uu7y6c90rqruhesae2t7c2vlw4uyyxlqxrx',
-      'agoric1d4228cvelf8tj65f4h7n2td90sscavln2283h5',
-      'agoric14543m33dr28x7qhwc558hzlj9szwhzwzpcmw6a',
-    ],
-  );
-  console.timeLog('DefaultTestContext', 'governanceDriver');
-
-  const priceFeedDriver = await makePriceFeedDriver(
-    storage,
-    agoricNamesRemotes,
-    walletFactoryDriver,
-    // TODO read from the config file
-    [
-      'agoric1krunjcqfrf7la48zrvdfeeqtls5r00ep68mzkr',
-      'agoric19uscwxdac6cf6z7d5e26e0jm0lgwstc47cpll8',
-      'agoric144rrhh4m09mh7aaffhm6xy223ym76gve2x7y78',
-      'agoric19d6gnr9fyp6hev4tlrg87zjrzsd5gzr5qlfq2p',
-      'agoric1n4fcxsnkxe4gj6e24naec99hzmc4pjfdccy5nj',
-    ],
-  );
-
-  console.timeLog('DefaultTestContext', 'priceFeedDriver');
-
-  console.timeEnd('DefaultTestContext');
-
-  const setupStartingState = async () => {
-    const { advanceTimeBy, readLatest } = swingsetTestKit;
-    // price feed logic treats zero time as "unset" so advance to nonzero
-    await advanceTimeBy(1, 'seconds');
-
-    await priceFeedDriver.setPrice(12.34);
-
-    // raise the VaultFactory DebtLimit
-    await governanceDriver.changeParams(
-      agoricNamesRemotes.instance.VaultFactory,
-      {
-        DebtLimit: {
-          brand: agoricNamesRemotes.brand.IST,
-          value: DebtLimitValue,
-        },
-      },
-      {
-        paramPath: {
-          key: {
-            collateralBrand: agoricNamesRemotes.brand.ATOM,
-          },
-        },
-      },
-    );
-
-    // raise the PSM MintLimit
-    await governanceDriver.changeParams(
-      agoricNamesRemotes.instance['psm-IST-USDC_axl'],
-      {
-        MintLimit: {
-          brand: agoricNamesRemotes.brand.IST,
-          value: DebtLimitValue, // reuse
-        },
-      },
-    );
-
-    // confirm Relevant Governance Parameter Assumptions
-    t.like(readLatest('published.vaultFactory.managers.manager0.governance'), {
-      current: {
-        DebtLimit: { value: { value: DebtLimitValue } },
-        InterestRate: {
-          type: 'ratio',
-          value: { numerator: { value: 1n }, denominator: { value: 100n } },
-        },
-        LiquidationMargin: {
-          type: 'ratio',
-          value: { numerator: { value: 150n }, denominator: { value: 100n } },
-        },
-        LiquidationPadding: {
-          type: 'ratio',
-          value: { numerator: { value: 25n }, denominator: { value: 100n } },
-        },
-        LiquidationPenalty: {
-          type: 'ratio',
-          value: { numerator: { value: 1n }, denominator: { value: 100n } },
-        },
-        MintFee: {
-          type: 'ratio',
-          value: { numerator: { value: 50n }, denominator: { value: 10_000n } },
-        },
-      },
-    });
-    t.like(readLatest('published.auction.governance'), {
-      current: {
-        AuctionStartDelay: { type: 'relativeTime', value: { relValue: 2n } },
-        ClockStep: {
-          type: 'relativeTime',
-          value: { relValue: 3n * SECONDS_PER_MINUTE },
-        },
-        DiscountStep: { type: 'nat', value: 500n }, // 5%
-        LowestRate: { type: 'nat', value: 6500n }, // 65%
-        PriceLockPeriod: {
-          type: 'relativeTime',
-          value: { relValue: SECONDS_PER_HOUR / 2n },
-        },
-        StartFrequency: {
-          type: 'relativeTime',
-          value: { relValue: SECONDS_PER_HOUR },
-        },
-        StartingRate: { type: 'nat', value: 10500n }, // 105%
-      },
-    });
-  };
-
-  const check = {
-    vaultNotification(vaultIndex, partial) {
-      const { readLatest } = swingsetTestKit;
-
-      const notification = readLatest(
-        `published.vaultFactory.managers.manager0.vaults.vault${vaultIndex}`,
-      );
-      t.like(notification, partial);
-    },
-  };
-
-  console.timeEnd('DefaultTestContext');
-
-  const buildProposal = makeProposalExtractor({
-    childProcess: processAmbient,
-    fs: fsAmbient.promises,
-  });
-
-  return {
-    ...swingsetTestKit,
-    agoricNamesRemotes,
-    check,
-    governanceDriver,
-    priceFeedDriver,
-    setupStartingState,
-    walletFactoryDriver,
-    buildProposal,
-  };
-};
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/test-liquidation-compatibility.js b/packages/vats/test/bootstrapTests/liquidationVisibility/test-liquidation-compatibility.js
deleted file mode 100644
index 882378e7d40..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/test-liquidation-compatibility.js
+++ /dev/null
@@ -1,105 +0,0 @@
-// @ts-check
-import { test as anyTest } from '@agoric/zoe/tools/prepare-test-env-ava.js';
-import {
-  checkVMChildNodes,
-  makeTestContext,
-} from './liquidation-test-utils.js';
-
-/**
- * @type {import('ava').TestFn<Awaited<ReturnType<typeof makeTestContext>>>}
- */
-const test = anyTest;
-
-test.before(async t => {
-  t.context = await makeTestContext(t);
-});
-test.after.always(t => t.context.shutdown?.());
-
-test.serial('visibility-before-upgrade', async t => {
-  await checkVMChildNodes({
-    t,
-    managerIndex: 0,
-    collateralBrandKey: 'ATOM',
-    liquidation: false,
-  });
-});
-
-test.serial('upgrade vaultFactory', async t => {
-  const {
-    controller,
-    buildProposal,
-    runUtils: { EV },
-  } = t.context;
-
-  t.log('building vaultFactory proposal');
-  const proposal = await buildProposal({
-    package: 'inter-protocol',
-    packageScriptName: 'build:upgrade-vaults-proposal',
-  });
-
-  for await (const bundle of proposal.bundles) {
-    await controller.validateAndInstallBundle(bundle);
-  }
-  t.log(
-    'bundles installed',
-    proposal.bundles[0].endoZipBase64Sha512,
-    proposal.bundles[1].endoZipBase64Sha512,
-  );
-
-  /** @type {Awaited<import('@agoric/inter-protocol/src/proposals/econ-behaviors.js').EconomyBootstrapSpace['consume']['vaultFactoryKit']>} */
-  const vaultFactoryKit = await EV.vat('bootstrap').consumeItem(
-    'vaultFactoryKit',
-  );
-
-  // @ts-expect-error cast XXX missing from type
-  const { privateArgs } = vaultFactoryKit;
-  console.log('reused privateArgs', privateArgs, vaultFactoryKit);
-
-  const vfAdminFacet = await EV(
-    vaultFactoryKit.governorCreatorFacet,
-  ).getAdminFacet();
-
-  t.log('awaiting VaultFactory upgradeContract');
-
-  const bundleId = `b1-${proposal.bundles[0].endoZipBase64Sha512}`;
-  const upgradeResult = await EV(vfAdminFacet).upgradeContract(
-    bundleId,
-    privateArgs,
-  );
-  t.deepEqual(upgradeResult, { incarnationNumber: 1 });
-  t.log('VaultFactory upgraded');
-});
-
-test.serial('restart contractGovernor', async t => {
-  const { EV } = t.context.runUtils;
-  /** @type {Awaited<import('@agoric/inter-protocol/src/proposals/econ-behaviors.js').EconomyBootstrapSpace['consume']['vaultFactoryKit']>} */
-  const vaultFactoryKit = await EV.vat('bootstrap').consumeItem(
-    'vaultFactoryKit',
-  );
-
-  const { governorAdminFacet } = vaultFactoryKit;
-  // has no privateArgs of its own. the privateArgs.governed is only for the
-  // contract startInstance. any changes to those privateArgs have to happen
-  // through a restart or upgrade using the governed contract's adminFacet
-  const privateArgs = undefined;
-
-  t.log('awaiting CG restartContract');
-  const upgradeResult = await EV(governorAdminFacet).restartContract(
-    privateArgs,
-  );
-  t.deepEqual(upgradeResult, { incarnationNumber: 1 });
-});
-
-test.serial('visibility-after-upgrade', async t => {
-  const { storage } = t.context;
-  await checkVMChildNodes({
-    t,
-    managerIndex: 0,
-    collateralBrandKey: 'ATOM',
-    liquidation: true,
-    base: 3,
-  });
-
-  t.log('Data', storage.data.keys());
-  t.pass();
-});
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/AttackersGuide.md b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/AttackersGuide.md
deleted file mode 100644
index fdbdaf83e35..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/AttackersGuide.md
+++ /dev/null
@@ -1,76 +0,0 @@
-# An Attacker's guide to the Vault Factory
-
-This is an incomplete list of potential weak points that an attacker might want to focus
-on when looking for ways to violate the integrity of the Vault Factory. It's here to help
-defenders, as "attacker's mindset" is a good way to focus attention for the defender. The
-list should correspond pretty closely to the set of assurances that the Vault Factory aims
-to support.
-
-The VaultFactory's purpose is to make it possible for users to deposit valuable tokens and
-borrow `Minted` in exchange. They will pay interest on the total outstanding balance, and have
-to pay off the debt or deposit additional collateral to ensure that the ratio of debt to
-collateral stays above a threshold. When the VaultManager detects that the ratio has
-fallen below the limit, their collateral will be sold.
-
-Part of the purpose of the Vault mechanism is to link the price of `Minted` to
-dollar-equivalents. We're currently getting prices from a configured PriceAuthority in
-RUN, but this should (https://github.com/Agoric/agoric-sdk/issues/4714) be changed to be
-priced in US Dollars. Tying the price at which Vaults lend `Minted` to the dollar price of the
-collateral is intended to set a ceiling on what one might pay for `Minted`. The fact that
-vaults get liquidated to the AMM if the dollar-value of the collateral falls below the
-required ratio should restore the value of `Minted` when collateral values fall. In DAI, the
-same linkage is enforced by auctioning off the collateral. Does selling into the AMM
-achieve the same end?
-
-## VaultManager
-
-Collateral from all borrowers who have deposited the same currency is intermingled. If we
-don't keep good records or can be confused about how much belongs to whom, there could be
-unintended interactions between the vaults held by a single VaultManager on behalf of
-different users.
-
-The VaultManagers calculate interest once daily, and record the change centrally without
-updating individual vaults. Vault owners must not be able to adjust balances or close
-their vault without being impacted by their up-to-date debt.
-
-## Fees
-
-Fees are charged when Vaults are opened, and as interest is charged. That money is
-available to be collected by the creator of the VaultFactory. Is the fee collection
-interface guarded carefully enough? Can any unintended party collect the fees?
-
-## `Minted` Mint
-
-The VaultManager has access to the `Minted` mint, and can create new `Minted` freely. This power is
-shared with every Vault, so if they can be suborned, arbitrary `Minted` can be created. Is this
-power sufficiently constrained?
-
-## Vaults
-
-When the user repays their debt, they can withdraw collateral. Actually, they can withdraw
-collateral to the extent that it isn't required by the current loan. Can they ever
-withdraw more than that, and leave their loan under-collateralized?
-
-If prices are falling and the trader can see that more clearly than the Vaults do, could
-they withdraw liquidity before the Vaults realize that the price has changed? We
-understand this is a distributed, asynchronous system, so to some extent, this is
-inevitable. Are the Vaults more susceptible to this than is justifiable?
-
-Vaults are stored in an orderedStore so that they can be efficiently liquidated in the
-order from least to most collateralized. Are there any edge cases that would cause Vaults
-to not be processed in the right order? Could a Vault escape the queue and evade
-liquidation?
-
-## Burn
-
-We burn amounts from liquidation and from paying off debts. Do we always get the amounts
-right? Do we burn everywhere we should? Reallocate ensures that rights are conserved, so
-no `Minted` is created or destroyed in reallocation. If we burn the wrong amounts, someone will
-end up with too much or too little.
-
-## Liquidation
-
-The liquidation mechanism is subject to governance. Is the current strategy legible
-(i.e. can Vault users tell how the liquidation will be carried out?) Is the liquidation
-approach destabilizing?
- 
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/Liquidation.md b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/Liquidation.md
deleted file mode 100644
index 2a353b09f0d..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/Liquidation.md
+++ /dev/null
@@ -1,100 +0,0 @@
-The liquidation approach relies on a descending clock auction (a
-"dutch" auction). The auction runs at a rate controlled by governed
-parameters. Every auction period, each vaultManager checks to see which
-vaults are under-water compared to an oracle price captured before the
-auction start. The collateral from all those illiquid vaults are sent to the
-auction, which attempts to sell them for enough to cover their outstanding
-debt at  a discount to their value. Since they are over-collateralized this
-should normally cover the debt and possibly return excess collateral. When
-that is the case (flow 1, below) , we repay the debt, charge a liquidation fee,
-and return excess collateral to the vault holders.
-
-There are two interesting exception cases. All the collateral might be sold
-without covering the debt (flow 2a), or there might not be enough bids to
-purchase all the collateral (flow 2b). In the first case, vault-holders don't
-get anything back, we burn the currency we received to cover a portion of the
-debt, and we report a shortfall.
-
-In the second case, we can't tell whether it's due to a downturn in the
-market or a DoS attack on the exchange. In hopes that it's not the latter, we
-reinstate as many vaults as can be made whole, declare the rest liquidated,
-and expect the next liquidation opportunity either to find the price has
-recovered, or to send a possibly different set of vaults to the next auction.
-
-
-**Flow 1: Auction raises enough IST to cover debt**
-
-The following steps occur in this order
-
-1. IST raised by the auction is burned to reduce debt in 1:1 ratio.
-
-- Definitionally, this should result in zero debt. Since the auction should stop
-  when it raises enough IST, it should result in zero IST remaining as well.
-  However, if some excess IST exists, it should be transferred to the reserve.
-
-2. From any remaining collateral, the liquidation penalty is taken and
-   transferred to the reserve.
-
-- Liquidation penalty is calculated as debt / current oracle price at auction
-  start * liquidation penalty
-
-3. Excess collateral - if any - is returned to vault holders
-
-- Vault holders receive collateral back sequenced by highest collateralization
-  ratio at liquidation time first.
-- The max amount of collateral a vault should be able to receive back is:
-  original collateral - collateral covering their share of debt (using average
-  liquidation price) - collateral covering their share of the penalty (their
-  debt / total debt \* total penalty)
-
-**Flow 2: Auction does not raise enough to cover IST debt**
-
-This flow further bifurcates based on whether the auction has sold all its
-collateral asset and still has not covered the debt or has collateral
-remaining (which simply did not receive bidders)
-
-**Flow 2a: all collateral sold and debt is not covered**
-
-1. IST raised by the auction is burned to reduce debt in 1:1 ratio.
-
-- Definitionally, this should result in zero IST remaining and some debt
-  remaining.
-
-2. Remaining debt is recorded in the reserve as a shortfall
-   
-   *sequence ends; no penalty is taken and vaults receive nothing back*
-
-**Flow 2b: collateral remains but debt is still not covered by IST raised by
-auction end**
-
-1. IST raised by the auction is burned to reduce debt in 1:1 ratio.
-
-- Definitionally, this should result in zero IST remaining and some debt remaining.
-
-2. From any remaining collateral, the liquidation penalty is taken and
-   transferred to the reserve.
-
-- Liquidation penalty is calculated as debt / current oracle price at auction
-  start \* liquidation penalty.
-
-  _Note: there now should be debt remaining and possibly collateral remaining_
-
-3. The vault manager now iterates through the vaults that were liquidated and
-   attempts to reconstitute them (minus collateral from the liquidation penalty)
-   starting from the best CR to worst.
-
-- Reconstitution means full prior debt AND full prior collateral minus
-  collateral used from penalty.
-- Collateral used for penalty = vault debt / total debt \* total liquidation penalty.
-- Debt that is given back to a vault should be subtracted from the vault
-  manager's view of remaining liquidation debt (i.e., it shouldn't be
-  double counted)
-- Reconstituted vaults are set to OPEN status (i.e., they are live again
-  and able to be interacted with)
-
-4. When the vault manager reaches a vault it cannot fully reconstitute
-   (both full debt and collateral as described above), it marks that vault as
-   liquidated. It then marks all other lower CR vaults as liquidated.
-5. Any remaining collateral is transferred to the reserve.
-6. Any remaining debt (subtracting debt that was given back to reconstituted
-   vaults, as described above) is transferred to the reserve as shortfall.
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/burn.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/burn.js
deleted file mode 100644
index 9cfc83b7f7a..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/burn.js
+++ /dev/null
@@ -1,17 +0,0 @@
-// @jessie-check
-
-import '@agoric/zoe/exported.js';
-
-import { E } from '@endo/eventual-send';
-
-/**
- * @param {ZCF} zcf
- * @param {ZCFMint} zcfMint
- * @param {Amount} amount
- */
-export const paymentFromZCFMint = async (zcf, zcfMint, amount) => {
-  const { zcfSeat, userSeat } = zcf.makeEmptySeatKit();
-  zcfMint.mintGains(harden({ Temp: amount }), zcfSeat);
-  zcfSeat.exit();
-  return E(userSeat).getPayout('Temp');
-};
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/liquidation.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/liquidation.js
deleted file mode 100644
index 0f38bb4696b..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/liquidation.js
+++ /dev/null
@@ -1,299 +0,0 @@
-// @jessie-check
-
-import { AmountMath } from '@agoric/ertp';
-import { makeTracer } from '@agoric/internal';
-import { observeIteration, subscribeEach } from '@agoric/notifier';
-import { makeScalarMapStore } from '@agoric/store';
-import { TimeMath } from '@agoric/time';
-import { atomicRearrange } from '@agoric/zoe/src/contractSupport/index.js';
-import { E } from '@endo/eventual-send';
-
-import {
-  AUCTION_START_DELAY,
-  PRICE_LOCK_PERIOD,
-} from '@agoric/inter-protocol/src/auction/params.js';
-import { makeCancelTokenMaker } from '@agoric/inter-protocol/src/auction/util.js';
-
-const trace = makeTracer('LIQ');
-
-/** @typedef {import('@agoric/time/src/types').TimerService} TimerService */
-/** @typedef {import('@agoric/time/src/types').TimerWaker} TimerWaker */
-/** @typedef {import('@agoric/time/src/types').CancelToken} CancelToken */
-/** @typedef {import('@agoric/time/src/types').RelativeTimeRecord} RelativeTimeRecord */
-
-const makeCancelToken = makeCancelTokenMaker('liq');
-
-/**
- * This will normally be set. If the schedule goes sideways, we'll unschedule
- * all events and unset it. When auction params are changed, we'll restart the schedule
- *
- * @type {object | undefined}
- */
-let cancelToken = makeCancelToken();
-
-const waitForRepair = () => {
-  // the params observer will setWakeup to resume.
-  console.warn(
-    '🛠️ No wake for reschedule. Repair by resetting auction params.',
-  );
-};
-
-// Generally, canceling wakups has to be followed by setting up new ones but
-// not in the case of pausing wakeups. We do that in the event of invalid
-// schedule params. When they are repaired by governance, the wakers resume.
-/** @param {ERef<TimerService>} timer */
-const cancelWakeups = timer => {
-  if (cancelToken) {
-    void E(timer).cancel(cancelToken);
-  }
-  cancelToken = undefined;
-};
-
-/**
- * Schedule wakeups for the *next* auction round.
- *
- * In practice, there are these cases to handle (with N as "live" and N+1 is "next"):
- *
- * | when (now within the range)      | what                                    |
- * | -------------------------------- | --------------------------------------- |
- * | [start N, nominalStart N+1]      | good: schedule normally the three wakers|
- * | (nominalStart N+1, endTime N+1]  | recover: skip round N+1 and schedule N+2|
- * | (endTime N+1, ∞)                 | give up: wait for repair by governance  |
- *
- * @param {object} opts
- * @param {ERef<TimerService>} opts.timer
- * @param {TimerWaker} opts.priceLockWaker
- * @param {TimerWaker} opts.liquidationWaker
- * @param {TimerWaker} opts.reschedulerWaker
- * @param {import('@agoric/inter-protocol/src/auction/scheduler.js').Schedule} opts.nextAuctionSchedule
- * @param {import('@agoric/time/src/types').TimestampRecord} opts.now
- * @param {ParamStateRecord} opts.params
- * @returns {void}
- */
-const setWakeups = ({
-  nextAuctionSchedule,
-  now,
-  timer,
-  reschedulerWaker,
-  liquidationWaker,
-  priceLockWaker,
-  params,
-}) => {
-  const { startTime, endTime } = nextAuctionSchedule;
-
-  /** @type {RelativeTimeRecord} */
-  // @ts-expect-error Casting
-  // eslint-disable-next-line no-restricted-syntax -- https://github.com/Agoric/eslint-config-jessie/issues/33
-  const priceLockPeriod = params[PRICE_LOCK_PERIOD].value;
-  /** @type {RelativeTimeRecord} */
-  // @ts-expect-error Casting
-  // eslint-disable-next-line no-restricted-syntax -- https://github.com/Agoric/eslint-config-jessie/issues/33
-  const auctionStartDelay = params[AUCTION_START_DELAY].value;
-
-  // nominal is the declared start time, but the actual auctioning begins after auctionStartDelay
-  const nominalStart = TimeMath.subtractAbsRel(startTime, auctionStartDelay);
-
-  // Is there a problem (case 2 or 3)?
-  // setWakeupsForNextAuction is supposed to be called just after an auction
-  // started. If we're late but there's still time for the nominal start, then
-  // we'll proceed. Reschedule for the next round if that's still in the future.
-  // Otherwise, wait for governance params to change.
-  if (TimeMath.compareAbs(now, nominalStart) > 0) {
-    // nominalStart is past, so cancel timers and plan to recover
-    cancelWakeups(timer);
-
-    if (TimeMath.compareAbs(now, endTime) < 0) {
-      // We're currently scheduling the N+1 (where N is live), but we need to skip it.
-      // So wake up for the N+2 round's startTime
-      const afterNextStartTime = TimeMath.addAbsRel(endTime, 1n);
-      trace(
-        'CASE 2: endTime is in the future or now so reschedule waking to startTime of the following round',
-        afterNextStartTime,
-      );
-      void E(timer).setWakeup(afterNextStartTime, reschedulerWaker);
-    } else {
-      trace('CASE 3: endTime is past; wait for repair');
-      waitForRepair();
-    }
-
-    return;
-  }
-  trace('CASE 1: nominalStart is now or in the future');
-
-  cancelToken = cancelToken || makeCancelToken();
-  const priceLockWakeTime = TimeMath.subtractAbsRel(
-    nominalStart,
-    priceLockPeriod,
-  );
-  const a = t => TimeMath.absValue(t);
-  trace('scheduling ', a(priceLockWakeTime), a(nominalStart), a(startTime));
-  void E(timer).setWakeup(priceLockWakeTime, priceLockWaker, cancelToken);
-  void E(timer).setWakeup(nominalStart, liquidationWaker, cancelToken);
-  // Call setWakeupsForNextAuction again one tick after nominalStart
-  const afterStart = TimeMath.addAbsRel(startTime, 1n);
-  void E(timer).setWakeup(afterStart, reschedulerWaker, cancelToken);
-};
-
-/**
- * Schedule wakeups for the *next* auction round.
- *
- * Called by vaultDirector's resetWakeupsForNextAuction at start() and every
- * time there's a "reschedule" wakeup.
- *
- * @param {ERef<import('@agoric/inter-protocol/src/auction/auctioneer.js').AuctioneerPublicFacet>} auctioneerPublicFacet
- * @param {ERef<TimerService>} timer
- * @param {TimerWaker} priceLockWaker
- * @param {TimerWaker} liquidationWaker
- * @param {TimerWaker} reschedulerWaker
- * @returns {Promise<void>}
- */
-export const setWakeupsForNextAuction = async (
-  auctioneerPublicFacet,
-  timer,
-  priceLockWaker,
-  liquidationWaker,
-  reschedulerWaker,
-) => {
-  const [{ nextAuctionSchedule }, params, now] = await Promise.all([
-    E(auctioneerPublicFacet).getSchedules(),
-    E(auctioneerPublicFacet).getGovernedParams(),
-    E(timer).getCurrentTimestamp(),
-  ]);
-
-  trace(
-    'setWakeupsForNextAuction at',
-    now.absValue,
-    'with',
-    nextAuctionSchedule,
-  );
-  if (!nextAuctionSchedule) {
-    // There should always be a nextAuctionSchedule. If there isn't, give up for now.
-    cancelWakeups(timer);
-    waitForRepair();
-    return;
-  }
-
-  setWakeups({
-    nextAuctionSchedule,
-    now,
-    timer,
-    reschedulerWaker,
-    liquidationWaker,
-    priceLockWaker,
-    params,
-  });
-};
-harden(setWakeupsForNextAuction);
-
-/**
- * @param {Amount<'nat'>} debt
- * @param {Amount<'nat'>} minted
- * @returns {{ overage: Amount<'nat'>, shortfall: Amount<'nat'>}}
- */
-export const liquidationResults = (debt, minted) => {
-  if (AmountMath.isEmpty(minted)) {
-    return { overage: minted, shortfall: debt };
-  }
-
-  const [overage, shortfall] = AmountMath.isGTE(debt, minted)
-    ? [AmountMath.makeEmptyFromAmount(debt), AmountMath.subtract(debt, minted)]
-    : [AmountMath.subtract(minted, debt), AmountMath.makeEmptyFromAmount(debt)];
-
-  return { overage, shortfall };
-};
-harden(liquidationResults);
-
-/**
- * Watch governed params for change
- *
- * @param {ERef<import('@agoric/inter-protocol/src/auction/auctioneer.js').AuctioneerPublicFacet>} auctioneerPublicFacet
- * @param {ERef<TimerService>} timer
- * @param {TimerWaker} reschedulerWaker
- * @returns {void}
- */
-export const watchForGovernanceChange = (
-  auctioneerPublicFacet,
-  timer,
-  reschedulerWaker,
-) => {
-  void E.when(E(timer).getCurrentTimestamp(), now =>
-    // make one observer that will usually ignore the update.
-    observeIteration(
-      subscribeEach(E(auctioneerPublicFacet).getSubscription()),
-      harden({
-        async updateState(_newState) {
-          if (!cancelToken) {
-            cancelToken = makeCancelToken();
-            void E(timer).setWakeup(
-              // bump one tick to prevent an infinite loop
-              TimeMath.addAbsRel(now, 1n),
-              reschedulerWaker,
-              cancelToken,
-            );
-          }
-        },
-      }),
-    ),
-  );
-};
-
-/**
- * @param {ZCF} zcf
- * @param {object} collateralizationDetails
- * @param {PriceQuote} collateralizationDetails.quote
- * @param {Ratio} collateralizationDetails.interest
- * @param {Ratio} collateralizationDetails.margin
- * @param {ReturnType<typeof import('./prioritizedVaults.js').makePrioritizedVaults>} prioritizedVaults
- * @param {SetStore<Vault>} liquidatingVaults
- * @param {Brand<'nat'>} debtBrand
- * @param {Brand<'nat'>} collateralBrand
- * @returns {{
- *    vaultData: MapStore<Vault, { collateralAmount: Amount<'nat'>, debtAmount:  Amount<'nat'>}>,
- *    totalDebt: Amount<'nat'>,
- *    totalCollateral: Amount<'nat'>,
- *    liqSeat: ZCFSeat}}
- */
-export const getLiquidatableVaults = (
-  zcf,
-  collateralizationDetails,
-  prioritizedVaults,
-  liquidatingVaults,
-  debtBrand,
-  collateralBrand,
-) => {
-  const vaultsToLiquidate = prioritizedVaults.removeVaultsBelow(
-    collateralizationDetails,
-  );
-  /** @type {MapStore<Vault, { collateralAmount: Amount<'nat'>, debtAmount:  Amount<'nat'>}>} */
-  const vaultData = makeScalarMapStore();
-
-  const { zcfSeat: liqSeat } = zcf.makeEmptySeatKit();
-  let totalDebt = AmountMath.makeEmpty(debtBrand);
-  let totalCollateral = AmountMath.makeEmpty(collateralBrand);
-  /** @type {import('@agoric/zoe/src/contractSupport/atomicTransfer.js').TransferPart[]} */
-  const transfers = [];
-
-  for (const vault of vaultsToLiquidate.values()) {
-    vault.liquidating();
-    liquidatingVaults.add(vault);
-
-    const collateralAmount = vault.getCollateralAmount();
-    totalCollateral = AmountMath.add(totalCollateral, collateralAmount);
-
-    const debtAmount = vault.getCurrentDebt();
-    totalDebt = AmountMath.add(totalDebt, debtAmount);
-    transfers.push([
-      vault.getVaultSeat(),
-      liqSeat,
-      { Collateral: collateralAmount },
-    ]);
-    vaultData.init(vault, { collateralAmount, debtAmount });
-  }
-
-  if (transfers.length > 0) {
-    atomicRearrange(zcf, harden(transfers));
-  }
-
-  return { vaultData, totalDebt, totalCollateral, liqSeat };
-};
-harden(getLiquidatableVaults);
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/math.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/math.js
deleted file mode 100644
index bab37d521e0..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/math.js
+++ /dev/null
@@ -1,95 +0,0 @@
-// @jessie-check
-
-/**
- * @file calculations specific to the Vault Factory contract
- * See also ../interest-math.js
- */
-
-import { AmountMath } from '@agoric/ertp';
-import { getAmountOut } from '@agoric/zoe/src/contractSupport/priceQuote.js';
-import {
-  addRatios,
-  ceilMultiplyBy,
-  floorDivideBy,
-  ratioGTE,
-} from '@agoric/zoe/src/contractSupport/ratio.js';
-import { priceFrom } from '@agoric/inter-protocol/src/auction/util.js';
-import { addSubtract } from '@agoric/inter-protocol/src/contractSupport.js';
-
-/**
- * Calculate the minimum collateralization given the liquidation margin and the "padding"
- * from that liquidation threshold.
- *
- * @param {Ratio} liquidationMargin
- * @param {Ratio} liquidationPadding
- * @returns {Ratio}
- */
-export const calculateMinimumCollateralization = (
-  liquidationMargin,
-  liquidationPadding,
-) => addRatios(liquidationMargin, liquidationPadding);
-
-/**
- * Calculate the lesser price of the given quotes.
- *
- * @param {PriceQuote} quoteA
- * @param {PriceQuote} [quoteB]
- * @returns {Ratio}
- */
-export const minimumPrice = (quoteA, quoteB) => {
-  const priceA = priceFrom(quoteA);
-  if (quoteB === undefined) {
-    return priceA;
-  }
-  const priceB = priceFrom(quoteB);
-  if (ratioGTE(priceA, priceB)) {
-    return priceB;
-  } else {
-    return priceA;
-  }
-};
-harden(minimumPrice);
-
-/**
- * Calculate the maximum debt allowed based on the price quote and the lesser of
- * the `liquidationMargin` or the `liquidationPadding`.
- *
- * @param {PriceQuote} quoteAmount
- * @param {Ratio} liquidationMargin
- * @param {Ratio} liquidationPadding
- * @returns {Amount<'nat'>}
- */
-export const maxDebtForVault = (
-  quoteAmount,
-  liquidationMargin,
-  liquidationPadding,
-) => {
-  const debtByQuote = getAmountOut(quoteAmount);
-  const minimumCollateralization = calculateMinimumCollateralization(
-    liquidationMargin,
-    liquidationPadding,
-  );
-  // floorDivide because we want the debt ceiling lower
-  return floorDivideBy(debtByQuote, minimumCollateralization);
-};
-
-/**
- * Calculate the fee, the amount to mint and the resulting debt.
- * The give and the want together reflect a delta, where typically
- * one is zero because they come from the gave/want of an offer
- * proposal. If the `want` is zero, the `fee` will also be zero,
- * so the simple math works.
- *
- * @param {Amount<'nat'>} currentDebt
- * @param {Amount<'nat'>} give excess of currentDebt is returned in 'surplus'
- * @param {Amount<'nat'>} want
- * @param {Ratio} debtFee
- */
-export const calculateDebtCosts = (currentDebt, give, want, debtFee) => {
-  const maxGive = AmountMath.min(currentDebt, give);
-  const surplus = AmountMath.subtract(give, maxGive);
-  const fee = ceilMultiplyBy(want, debtFee);
-  const toMint = AmountMath.add(want, fee);
-  const newDebt = addSubtract(currentDebt, toMint, maxGive);
-  return { newDebt, toMint, fee, surplus };
-};
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/orderedVaultStore.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/orderedVaultStore.js
deleted file mode 100644
index 7fd83d61244..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/orderedVaultStore.js
+++ /dev/null
@@ -1,69 +0,0 @@
-import { fromVaultKey, toVaultKey } from './storeUtils.js';
-
-/**
- * Used by prioritizedVaults to wrap the Collections API for this use case.
- *
- * Designed to be replaceable by naked Collections API when composite keys are available.
- *
- * In this module debts are encoded as the inverse quotient (collateral over debt) so that
- * greater collateralization sorts after lower. (Higher debt-to-collateral come
- * first.)
- */
-
-/** @typedef {import('./vault').Vault} Vault */
-/** @typedef {import('./storeUtils').CompositeKey} CompositeKey */
-
-/**
- * @param {MapStore<string, Vault>} store
- */
-export const makeOrderedVaultStore = store => {
-  /**
-   *
-   * @param {string} vaultId
-   * @param {Vault} vault
-   */
-  const addVault = (vaultId, vault) => {
-    const debt = vault.getNormalizedDebt();
-    const collateral = vault.getCollateralAmount();
-    const key = toVaultKey(debt, collateral, vaultId);
-    store.init(key, vault);
-    return key;
-  };
-
-  /**
-   *
-   * @param {string} key
-   * @returns {Vault}
-   */
-  const removeByKey = key => {
-    try {
-      const vault = store.get(key);
-      assert(vault);
-      store.delete(key);
-      return vault;
-    } catch (e) {
-      console.error(
-        'removeByKey failed to remove',
-        key,
-        '[ratio, vaultId]:',
-        fromVaultKey(key),
-      );
-      const keys = Array.from(store.keys());
-      console.error(
-        '  contents:',
-        keys.map(k => [k, fromVaultKey[k]]),
-      );
-      throw e;
-    }
-  };
-
-  return harden({
-    addVault,
-    removeByKey,
-    has: store.has,
-    keys: store.keys,
-    entries: store.entries,
-    getSize: store.getSize,
-    values: store.values,
-  });
-};
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/params.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/params.js
deleted file mode 100644
index 508f377834d..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/params.js
+++ /dev/null
@@ -1,220 +0,0 @@
-// @jessie-check
-
-import './types.js';
-
-import {
-  CONTRACT_ELECTORATE,
-  makeParamManagerSync,
-  ParamTypes,
-} from '@agoric/governance';
-import { makeStoredPublisherKit } from '@agoric/notifier';
-import { M, makeScalarMapStore } from '@agoric/store';
-import { TimeMath } from '@agoric/time';
-import { provideDurableMapStore } from '@agoric/vat-data';
-import { subtractRatios } from '@agoric/zoe/src/contractSupport/ratio.js';
-import {
-  amountPattern,
-  ratioPattern,
-} from '@agoric/inter-protocol/src/contractSupport.js';
-
-export const CHARGING_PERIOD_KEY = 'ChargingPeriod';
-export const RECORDING_PERIOD_KEY = 'RecordingPeriod';
-
-export const DEBT_LIMIT_KEY = 'DebtLimit';
-export const LIQUIDATION_MARGIN_KEY = 'LiquidationMargin';
-export const LIQUIDATION_PADDING_KEY = 'LiquidationPadding';
-export const LIQUIDATION_PENALTY_KEY = 'LiquidationPenalty';
-export const INTEREST_RATE_KEY = 'InterestRate';
-export const MINT_FEE_KEY = 'MintFee';
-export const MIN_INITIAL_DEBT_KEY = 'MinInitialDebt';
-export const SHORTFALL_INVITATION_KEY = 'ShortfallInvitation';
-export const REFERENCED_UI_KEY = 'ReferencedUI';
-
-export const vaultDirectorParamTypes = {
-  [MIN_INITIAL_DEBT_KEY]: ParamTypes.AMOUNT,
-  [CHARGING_PERIOD_KEY]: ParamTypes.NAT,
-  [RECORDING_PERIOD_KEY]: ParamTypes.NAT,
-  [REFERENCED_UI_KEY]: ParamTypes.STRING,
-};
-harden(vaultDirectorParamTypes);
-
-/**
- * @param {Amount<'set'>} electorateInvitationAmount
- * @param {Amount<'nat'>} minInitialDebt
- * @param {Amount<'set'>} shortfallInvitationAmount
- * @param {string} referencedUi
- * @param {InterestTiming} interestTiming
- */
-const makeVaultDirectorParams = (
-  electorateInvitationAmount,
-  minInitialDebt,
-  shortfallInvitationAmount,
-  referencedUi,
-  interestTiming,
-) => {
-  return harden({
-    [CONTRACT_ELECTORATE]: {
-      type: ParamTypes.INVITATION,
-      value: electorateInvitationAmount,
-    },
-    [MIN_INITIAL_DEBT_KEY]: {
-      type: ParamTypes.AMOUNT,
-      value: minInitialDebt,
-    },
-    [SHORTFALL_INVITATION_KEY]: {
-      type: ParamTypes.INVITATION,
-      value: shortfallInvitationAmount,
-    },
-    [REFERENCED_UI_KEY]: { type: ParamTypes.STRING, value: referencedUi },
-    [CHARGING_PERIOD_KEY]: {
-      type: ParamTypes.NAT,
-      value: TimeMath.relValue(interestTiming.chargingPeriod),
-    },
-    [RECORDING_PERIOD_KEY]: {
-      type: ParamTypes.NAT,
-      value: TimeMath.relValue(interestTiming.recordingPeriod),
-    },
-  });
-};
-harden(makeVaultDirectorParams);
-
-/** @typedef {import('@agoric/governance/src/contractGovernance/typedParamManager').ParamTypesMapFromRecord<ReturnType<typeof makeVaultDirectorParams>>} VaultDirectorParams */
-
-/** @type {(liquidationMargin: Ratio) => Ratio} */
-const zeroRatio = liquidationMargin =>
-  subtractRatios(liquidationMargin, liquidationMargin);
-
-/**
- * @param {import('@agoric/notifier').StoredPublisherKit<GovernanceSubscriptionState>} publisherKit
- * @param {VaultManagerParamValues} initial
- */
-export const makeVaultParamManager = (
-  publisherKit,
-  {
-    debtLimit,
-    interestRate,
-    liquidationMargin,
-    liquidationPadding = zeroRatio(liquidationMargin),
-    liquidationPenalty,
-    mintFee,
-  },
-) =>
-  makeParamManagerSync(publisherKit, {
-    [DEBT_LIMIT_KEY]: [ParamTypes.AMOUNT, debtLimit],
-    [INTEREST_RATE_KEY]: [ParamTypes.RATIO, interestRate],
-    [LIQUIDATION_PADDING_KEY]: [ParamTypes.RATIO, liquidationPadding],
-    [LIQUIDATION_MARGIN_KEY]: [ParamTypes.RATIO, liquidationMargin],
-    [LIQUIDATION_PENALTY_KEY]: [ParamTypes.RATIO, liquidationPenalty],
-    [MINT_FEE_KEY]: [ParamTypes.RATIO, mintFee],
-  });
-/** @typedef {ReturnType<typeof makeVaultParamManager>} VaultParamManager */
-
-export const vaultParamPattern = M.splitRecord(
-  {
-    liquidationMargin: ratioPattern,
-    liquidationPenalty: ratioPattern,
-    interestRate: ratioPattern,
-    mintFee: ratioPattern,
-    debtLimit: amountPattern,
-  },
-  {
-    // optional for backwards compatibility, e.g. with loadgen
-    liquidationPadding: ratioPattern,
-  },
-);
-
-/**
- * @param {{
- *   auctioneerPublicFacet: ERef<AuctioneerPublicFacet>,
- *   electorateInvitationAmount: Amount<'set'>,
- *   minInitialDebt: Amount<'nat'>,
- *   bootstrapPaymentValue: bigint,
- *   priceAuthority: ERef<PriceAuthority>,
- *   timer: ERef<import('@agoric/time/src/types').TimerService>,
- *   reservePublicFacet: AssetReservePublicFacet,
- *   interestTiming: InterestTiming,
- *   shortfallInvitationAmount: Amount<'set'>,
- *   referencedUi?: string,
- * }} opts
- */
-export const makeGovernedTerms = ({
-  auctioneerPublicFacet,
-  bootstrapPaymentValue,
-  electorateInvitationAmount,
-  interestTiming,
-  minInitialDebt,
-  priceAuthority,
-  reservePublicFacet,
-  timer,
-  shortfallInvitationAmount,
-  referencedUi = 'NO REFERENCE',
-}) => {
-  return harden({
-    auctioneerPublicFacet,
-    priceAuthority,
-    reservePublicFacet,
-    timerService: timer,
-    governedParams: makeVaultDirectorParams(
-      electorateInvitationAmount,
-      minInitialDebt,
-      shortfallInvitationAmount,
-      referencedUi,
-      interestTiming,
-    ),
-    bootstrapPaymentValue,
-  });
-};
-harden(makeGovernedTerms);
-/**
- * Stop-gap which restores initial param values
- * UNTIL https://github.com/Agoric/agoric-sdk/issues/5200
- *
- * NB: changes from initial values will be lost upon restart
- *
- * @param {import('@agoric/vat-data').Baggage} baggage
- * @param {ERef<Marshaller>} marshaller
- */
-export const provideVaultParamManagers = (baggage, marshaller) => {
-  /** @type {MapStore<Brand, VaultParamManager>} */
-  const managers = makeScalarMapStore();
-
-  // the managers aren't durable but their arguments are
-  /** @type {MapStore<Brand, {storageNode: StorageNode, initialParamValues: VaultManagerParamValues}>} */
-  const managerArgs = provideDurableMapStore(
-    baggage,
-    'vault param manager parts',
-  );
-
-  const makeManager = (brand, { storageNode, initialParamValues }) => {
-    const manager = makeVaultParamManager(
-      makeStoredPublisherKit(storageNode, marshaller, 'governance'),
-      initialParamValues,
-    );
-    managers.init(brand, manager);
-    return manager;
-  };
-
-  // restore from baggage
-  [...managerArgs.entries()].map(([brand, args]) => makeManager(brand, args));
-
-  return {
-    /**
-     *
-     * @param {Brand} brand
-     * @param {StorageNode} storageNode
-     * @param {VaultManagerParamValues} initialParamValues
-     */
-    addParamManager(brand, storageNode, initialParamValues) {
-      const args = harden({ storageNode, initialParamValues });
-      managerArgs.init(brand, args);
-      return makeManager(brand, args);
-    },
-    /**
-     * @param {Brand} brand
-     */
-    get(brand) {
-      return managers.get(brand);
-    },
-  };
-};
-harden(provideVaultParamManagers);
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/prioritizedVaults.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/prioritizedVaults.js
deleted file mode 100644
index 09384cb386c..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/prioritizedVaults.js
+++ /dev/null
@@ -1,151 +0,0 @@
-// @jessie-check
-
-import { makeTracer } from '@agoric/internal';
-import { makeRatioFromAmounts } from '@agoric/zoe/src/contractSupport/index.js';
-import { AmountMath } from '@agoric/ertp';
-import { Far } from '@endo/marshal';
-import { M } from '@agoric/vat-data';
-import { makeScalarMapStore } from '@agoric/store';
-import { makeOrderedVaultStore } from './orderedVaultStore.js';
-import {
-  toVaultKey,
-  normalizedCollRatioKey,
-  normalizedCollRatio,
-} from './storeUtils.js';
-
-/** @typedef {import('./vault').Vault} Vault */
-/** @typedef {import('./storeUtils.js').NormalizedDebt} NormalizedDebt */
-
-const trace = makeTracer('PVaults', true);
-
-/**
- * @param {Amount<'nat'>} debtAmount
- * @param {Amount<'nat'>} collateralAmount
- * @returns {Ratio}
- */
-const calculateDebtToCollateral = (debtAmount, collateralAmount) => {
-  if (AmountMath.isEmpty(collateralAmount)) {
-    return makeRatioFromAmounts(
-      debtAmount,
-      AmountMath.make(collateralAmount.brand, 1n),
-    );
-  }
-  return makeRatioFromAmounts(debtAmount, collateralAmount);
-};
-
-/**
- * @param {Vault} vault
- * @returns {Ratio}
- */
-export const currentDebtToCollateral = vault =>
-  calculateDebtToCollateral(
-    vault.getCurrentDebt(),
-    vault.getCollateralAmount(),
-  );
-
-/**
- * Vaults, ordered by their debt ratio so that all the vaults below a threshold
- * can be quickly found and liquidated.
- *
- * @param {MapStore<string, Vault>} store
- * vault has a higher debt ratio than the previous highest
- */
-export const makePrioritizedVaults = store => {
-  const vaults = makeOrderedVaultStore(store);
-
-  /**
-   * Ratio of the least-collateralized vault, if there is one.
-   *
-   * @returns {Ratio | undefined} actual debt over collateral
-   */
-  const highestRatio = () => {
-    if (vaults.getSize() === 0) {
-      return undefined;
-    }
-    // Get the first vault.
-    const [vault] = vaults.values();
-    assert(
-      !AmountMath.isEmpty(vault.getCollateralAmount()),
-      'First vault had no collateral',
-    );
-    return currentDebtToCollateral(vault);
-  };
-
-  /**
-   * @param {NormalizedDebt} oldDebt
-   * @param {Amount<'nat'>} oldCollateral
-   * @param {string} vaultId
-   */
-  const hasVaultByAttributes = (oldDebt, oldCollateral, vaultId) => {
-    const key = toVaultKey(oldDebt, oldCollateral, vaultId);
-    return vaults.has(key);
-  };
-
-  /**
-   * @param {string} key
-   * @returns {Vault}
-   */
-  const removeVault = key => {
-    const vault = vaults.removeByKey(key);
-    return vault;
-  };
-
-  /**
-   * @param {NormalizedDebt} oldDebt
-   * @param {Amount<'nat'>} oldCollateral
-   * @param {string} vaultId
-   */
-  const removeVaultByAttributes = (oldDebt, oldCollateral, vaultId) => {
-    const key = toVaultKey(oldDebt, oldCollateral, vaultId);
-    return removeVault(key);
-  };
-
-  /**
-   * @param {VaultId} vaultId
-   * @param {Vault} vault
-   */
-  const addVault = (vaultId, vault) => {
-    const key = vaults.addVault(vaultId, vault);
-    assert(
-      !AmountMath.isEmpty(vault.getCollateralAmount()),
-      'Tracked vaults must have collateral (be liquidatable)',
-    );
-    return key;
-  };
-
-  const removeVaultsBelow = ({ margin, quote, interest }) => {
-    // crKey represents a collateralizationRatio based on the locked price, the
-    // interest charged so far, and the liquidation margin.
-    // We'll remove all vaults below that ratio, and return them.
-    const crKey = normalizedCollRatioKey(quote, interest, margin);
-
-    trace(
-      `Liquidating vaults worse than`,
-      normalizedCollRatio(quote, interest, margin),
-    );
-
-    /** @type {MapStore<string, Vault>} */
-    const vaultsRemoved = makeScalarMapStore();
-
-    for (const [key, vault] of vaults.entries(M.lte(crKey))) {
-      vaultsRemoved.init(key, vault);
-      vaults.removeByKey(key);
-    }
-
-    return vaultsRemoved;
-  };
-
-  return Far('PrioritizedVaults', {
-    addVault,
-    entries: vaults.entries,
-    getCount: vaults.getSize,
-    hasVaultByAttributes,
-    highestRatio,
-    removeVault,
-    removeVaultByAttributes,
-    removeVaultsBelow,
-
-    // visible for testing
-    countVaultsBelow: crKey => vaults.getSize(M.lte(crKey)),
-  });
-};
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/proceeds.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/proceeds.js
deleted file mode 100644
index 7d9520e5295..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/proceeds.js
+++ /dev/null
@@ -1,277 +0,0 @@
-import { AmountMath } from '@agoric/ertp';
-import {
-  ceilDivideBy,
-  ceilMultiplyBy,
-  floorMultiplyBy,
-  makeRatioFromAmounts,
-  multiplyRatios,
-} from '@agoric/zoe/src/contractSupport/index.js';
-import {
-  quoteAsRatio,
-  subtractToEmpty,
-} from '@agoric/inter-protocol/src/contractSupport.js';
-import { liquidationResults } from './liquidation.js';
-
-/**
- * @typedef {{
- *   overage: Amount<'nat'>,
- *   shortfallToReserve: Amount<'nat'>,
- *   collateralForReserve: Amount<'nat'>,
- *   actualCollateralSold: Amount<'nat'>,
- *   collateralSold: Amount<'nat'>,
- *   collatRemaining: Amount<'nat'>,
- *   debtToBurn: Amount<'nat'>,
- *   mintedForReserve: Amount<'nat'>,
- *   mintedProceeds: Amount<'nat'>,
- *   phantomDebt: Amount<'nat'>,
- *   totalPenalty: Amount<'nat'>,
- *   transfersToVault: Array<[number, AmountKeywordRecord]>,
- *   vaultsToReinstate: Array<number>
- * }} DistributionPlan
- *
- * The plan to execute for distributing proceeds of a liquidation.
- *
- * Vaults are referenced by index in the list sent to the calculator.
- */
-
-/** @typedef {{ collateral: Amount<'nat'>, presaleDebt:  Amount<'nat'>, currentDebt: Amount<'nat'> }} VaultBalances */
-
-/**
- * Liquidation.md describes how to process liquidation proceeds.
- *
- * This function is complex and may fail. To defend against this possibility, it
- * starts with a base plan and updates it. The updating is the complex portion
- * and is wrapped in a try/catch. If at any point the plan revising fails, the
- * plan is returned as is.
- *
- * @param {object} inputs
- * @param {AmountKeywordRecord} inputs.proceeds
- * @param {Amount<'nat'>} inputs.totalDebt
- * @param {Amount<'nat'>} inputs.totalCollateral
- * @param {PriceDescription} inputs.oraclePriceAtStart
- * @param {Array<VaultBalances>} inputs.vaultsBalances ordered best to worst collateralized
- * @param {Ratio} inputs.penaltyRate
- * @returns {DistributionPlan}
- */
-export const calculateDistributionPlan = ({
-  proceeds,
-  totalDebt,
-  totalCollateral,
-  oraclePriceAtStart,
-  vaultsBalances,
-  penaltyRate,
-}) => {
-  const emptyCollateral = AmountMath.makeEmptyFromAmount(totalCollateral);
-  const emptyMinted = AmountMath.makeEmptyFromAmount(totalDebt);
-
-  const { Collateral: collateralProceeds } = proceeds;
-  /** @type {Amount<'nat'>} */
-  const collateralSold = AmountMath.subtract(
-    totalCollateral,
-    collateralProceeds,
-  );
-
-  const mintedProceeds = proceeds.Minted || emptyMinted;
-  const accounting = liquidationResults(totalDebt, mintedProceeds);
-
-  // charged in collateral
-  const totalPenalty = ceilMultiplyBy(
-    totalDebt,
-    multiplyRatios(penaltyRate, quoteAsRatio(oraclePriceAtStart)),
-  );
-
-  const debtPortion = makeRatioFromAmounts(totalPenalty, totalDebt);
-
-  // We mutate the plan so that at any point if there's an error the plan can be returned and executed.
-  // IOW the plan must always be in a valid state, though perhaps incomplete.
-  /** @type {DistributionPlan} */
-  const plan = {
-    overage: accounting.overage,
-    shortfallToReserve: accounting.shortfall,
-    collateralForReserve: emptyCollateral,
-    actualCollateralSold: emptyCollateral,
-    collateralSold,
-    collatRemaining: emptyCollateral,
-    debtToBurn: emptyMinted,
-    mintedForReserve: emptyMinted,
-    mintedProceeds,
-    phantomDebt: emptyMinted,
-    transfersToVault: [],
-    vaultsToReinstate: [],
-    totalPenalty,
-  };
-
-  /**
-   * If interest was charged between liquidating and liquidated, erase it.
-   *
-   * @param {VaultBalances} balances
-   */
-  const updatePhantomDebt = ({ presaleDebt, currentDebt }) => {
-    if (AmountMath.isEqual(presaleDebt, currentDebt)) {
-      return;
-    }
-    const accrued = AmountMath.subtract(currentDebt, presaleDebt);
-    plan.phantomDebt = AmountMath.add(plan.phantomDebt, accrued);
-  };
-
-  const runFlow1 = () => {
-    // Flow #1: no shortfall
-
-    const distributableCollateral = subtractToEmpty(
-      collateralProceeds,
-      totalPenalty,
-    );
-
-    plan.debtToBurn = totalDebt;
-    plan.mintedForReserve = accounting.overage;
-
-    // return remaining funds to vaults before closing
-
-    let leftToStage = distributableCollateral;
-    const price = makeRatioFromAmounts(mintedProceeds, collateralSold);
-
-    // iterate from best to worst, returning collateral until it has
-    // been exhausted. Vaults after that get nothing.
-    for (const [vaultIndex, balances] of vaultsBalances.entries()) {
-      const { collateral: vCollat, presaleDebt } = balances;
-      updatePhantomDebt(balances);
-
-      // max return is vault value reduced by debt and penalty value
-      const debtCollat = ceilDivideBy(presaleDebt, price);
-      const penaltyCollat = ceilMultiplyBy(presaleDebt, debtPortion);
-      const lessCollat = AmountMath.add(debtCollat, penaltyCollat);
-
-      const maxCollat = subtractToEmpty(vCollat, lessCollat);
-      if (!AmountMath.isEmpty(leftToStage)) {
-        const collatReturn = AmountMath.min(leftToStage, maxCollat);
-        leftToStage = AmountMath.subtract(leftToStage, collatReturn);
-        plan.transfersToVault.push([vaultIndex, { Collateral: collatReturn }]);
-      }
-    }
-
-    const hasCollateralToDistribute = !AmountMath.isEmpty(
-      distributableCollateral,
-    );
-    plan.collateralForReserve = hasCollateralToDistribute
-      ? AmountMath.add(leftToStage, totalPenalty)
-      : collateralProceeds;
-  };
-
-  // Flow 2a: all collateral was sold but debt was not covered
-  const runFlow2a = () => {
-    // charge penalty if proceeds are sufficient
-    const penaltyInMinted = ceilMultiplyBy(totalDebt, penaltyRate);
-    const recoveredDebt = AmountMath.min(
-      AmountMath.add(totalDebt, penaltyInMinted),
-      mintedProceeds,
-    );
-
-    plan.debtToBurn = recoveredDebt;
-
-    const distributable = subtractToEmpty(mintedProceeds, recoveredDebt);
-    let mintedRemaining = distributable;
-
-    const vaultPortion = makeRatioFromAmounts(distributable, totalCollateral);
-
-    // iterate from best to worst returning remaining funds to vaults
-    for (const [vaultIndex, balances] of vaultsBalances.entries()) {
-      // from best to worst, return minted above penalty if any remains
-      const vaultShare = floorMultiplyBy(balances.collateral, vaultPortion);
-      updatePhantomDebt(balances);
-
-      if (!AmountMath.isEmpty(mintedRemaining)) {
-        const mintedToReturn = AmountMath.min(mintedRemaining, vaultShare);
-        mintedRemaining = AmountMath.subtract(mintedRemaining, mintedToReturn);
-        plan.transfersToVault.push([vaultIndex, { Minted: mintedToReturn }]);
-      }
-    }
-  };
-
-  // Flow 2b: collateral remains but debt was not covered
-  const runFlow2b = () => {
-    plan.debtToBurn = totalDebt;
-    plan.mintedForReserve = accounting.overage;
-
-    // reconstitute vaults until collateral is insufficient
-    let reconstituteVaults = AmountMath.isGTE(collateralProceeds, totalPenalty);
-
-    // charge penalty if proceeds are sufficient
-    const distributableCollateral = subtractToEmpty(
-      collateralProceeds,
-      totalPenalty,
-    );
-
-    plan.collatRemaining = distributableCollateral;
-
-    let shortfallToReserve = accounting.shortfall;
-    const reduceCollateral = amount =>
-      (plan.actualCollateralSold = AmountMath.add(
-        plan.actualCollateralSold,
-        amount,
-      ));
-
-    // iterate from best to worst attempting to reconstitute, by
-    // returning remaining funds to vaults
-    for (const [vaultIndex, balances] of vaultsBalances.entries()) {
-      const { collateral: vCollat, presaleDebt } = balances;
-
-      // according to #7123, Collateral for penalty =
-      //   total liquidation penalty * vault debt / total debt
-      const vaultPenalty = ceilMultiplyBy(presaleDebt, debtPortion);
-      const collatPostPenalty = subtractToEmpty(vCollat, vaultPenalty);
-      const vaultDebt = floorMultiplyBy(presaleDebt, debtPortion);
-
-      // Should we continue reconstituting vaults?
-      reconstituteVaults =
-        reconstituteVaults &&
-        !AmountMath.isEmpty(collatPostPenalty) &&
-        AmountMath.isGTE(plan.collatRemaining, collatPostPenalty) &&
-        AmountMath.isGTE(totalDebt, presaleDebt);
-
-      if (reconstituteVaults) {
-        plan.collatRemaining = AmountMath.subtract(
-          plan.collatRemaining,
-          collatPostPenalty,
-        );
-        shortfallToReserve = subtractToEmpty(shortfallToReserve, presaleDebt);
-        // must reinstate after atomicRearrange(), so we record them.
-        plan.vaultsToReinstate.push(vaultIndex);
-        reduceCollateral(vaultDebt);
-        plan.transfersToVault.push([
-          vaultIndex,
-          { Collateral: collatPostPenalty },
-        ]);
-      } else {
-        updatePhantomDebt(balances);
-
-        reduceCollateral(vCollat);
-      }
-    }
-
-    plan.collateralForReserve = AmountMath.add(
-      plan.collatRemaining,
-      totalPenalty,
-    );
-
-    plan.shortfallToReserve = shortfallToReserve;
-  };
-
-  try {
-    if (AmountMath.isEmpty(accounting.shortfall)) {
-      // Flow #1: no shortfall
-      runFlow1();
-    } else if (AmountMath.isEmpty(collateralProceeds)) {
-      // Flow 2a: all collateral was sold but debt was not covered
-      runFlow2a();
-    } else {
-      // Flow #2b: There's unsold collateral; some vaults may be reinstated.
-      runFlow2b();
-    }
-  } catch (err) {
-    console.error('🚨 Failure running distribution flow:', err);
-    // continue to return `plan` in the state that was reached
-  }
-
-  return harden(plan);
-};
-harden(calculateDistributionPlan);
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/storeUtils.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/storeUtils.js
deleted file mode 100644
index ed5ea1b3e16..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/storeUtils.js
+++ /dev/null
@@ -1,171 +0,0 @@
-// @jessie-check
-
-/**
- * Module to improvise composite keys for orderedVaultStore until Collections
- * API supports them.
- */
-
-// XXX importing these that are declared to be used only for testing
-// until @agoric/store supports composite keys
-import { makeDecodePassable, makeEncodePassable } from '@endo/marshal';
-import {
-  getAmountIn,
-  getAmountOut,
-  natSafeMath,
-} from '@agoric/zoe/src/contractSupport/index.js';
-import { makeTracer } from '@agoric/internal';
-
-const { multiply } = natSafeMath;
-
-const trace = makeTracer('Store', true);
-
-/**
- * @typedef {import('@endo/marshal').PureData} PureData
- */
-
-/**
- * @typedef {[normalizedCollateralization: number, vaultId: VaultId]} CompositeKey
- */
-
-// `makeEncodePassable` has three named options:
-// `encodeRemotable`, `encodeError`, and `encodePromise`.
-// Those which are omitted default to a function that always throws.
-// So by omitting all three, we know that
-// the resulting function will encode only `PureData` arguments.
-/**
- * @param {PureData} key
- * @returns {string}
- */
-export const encodeData = makeEncodePassable();
-
-// `makeDecodePassable` has three named options:
-// `decodeRemotable`, `decodeError`, and `decodePromise`.
-// Those which are omitted default to a function that always throws.
-// So by omitting all three, we know that
-// the resulting function will decode only to `PureData` results.
-/**
- * @param {string} encoded
- * @returns {PureData}
- */
-export const decodeData = makeDecodePassable();
-
-/**
- * @param {number} n
- * @returns {string}
- */
-const encodeNumber = n => {
-  assert.typeof(n, 'number');
-  return encodeData(n);
-};
-
-/**
- * @param {string} encoded
- * @returns {number}
- */
-const decodeNumber = encoded => {
-  const result = decodeData(encoded);
-  assert.typeof(result, 'number');
-  return result;
-};
-
-// Type annotations to support static testing of amount values
-/** @typedef {Amount<'nat'> & {normalized: true}} NormalizedDebt */
-/** @typedef {Amount<'nat'> & {normalized: false}} ActualDebt */
-
-/**
- * Overcollateralized are greater than one.
- * The more undercollaterized the smaller in [0-1].
- *
- * @param {NormalizedDebt} normalizedDebt normalized (not actual) total debt
- * @param {Amount<'nat'>} collateral
- * @returns {number}
- */
-const collateralizationRatio = (normalizedDebt, collateral) => {
-  const c = Number(collateral.value);
-  const d = normalizedDebt.value
-    ? Number(normalizedDebt.value)
-    : Number.EPSILON;
-  return c / d;
-};
-
-/**
- * Sorts by ratio in descending debt. Ordering of vault id is undefined.
- *
- * @param {NormalizedDebt} normalizedDebt normalized (not actual) total debt
- * @param {Amount<'nat'>} collateral
- * @param {VaultId} vaultId
- * @returns {string} lexically sortable string in which highest
- * debt-to-collateral is earliest
- */
-export const toVaultKey = (normalizedDebt, collateral, vaultId) => {
-  assert(normalizedDebt);
-  assert(collateral);
-  assert(vaultId);
-  // until DB supports composite keys, copy its method for turning numbers to DB
-  // entry keys
-  const numberPart = encodeNumber(
-    collateralizationRatio(normalizedDebt, collateral),
-  );
-
-  trace(`To Vault Key `, collateralizationRatio(normalizedDebt, collateral));
-  return `${numberPart}:${vaultId}`;
-};
-harden(toVaultKey);
-
-/**
- * @param {string} key
- * @returns {[normalizedCollateralization: number, vaultId: VaultId]}
- */
-export const fromVaultKey = key => {
-  const [numberPart, vaultIdPart] = key.split(':');
-  return [decodeNumber(numberPart), vaultIdPart];
-};
-harden(fromVaultKey);
-
-/**
- * Create a float representing a Normalized Collateralization Ratio that can be
- * compared to the NCRs of vaults. We want a float with as much resolution as we
- * can get, so we multiply out the numerator and the denominator, and only
- * divide the results once.
- *
- * For use by `normalizedCollRatioKey` and tests.
- *
- * @param {PriceQuote} quote
- * @param {Ratio} compoundedInterest
- * @param {Ratio} margin
- * @returns {number}
- */
-export const normalizedCollRatio = (quote, compoundedInterest, margin) => {
-  const amountIn = getAmountIn(quote).value;
-  const amountOut = getAmountOut(quote).value;
-  const interestNumerator = compoundedInterest.numerator.value;
-  const interestBase = compoundedInterest.denominator.value;
-  const numerator = multiply(
-    margin.numerator.value,
-    multiply(amountIn, interestNumerator),
-  );
-  const denominator = multiply(
-    amountOut,
-    multiply(interestBase, margin.denominator.value),
-  );
-
-  return Number(numerator) / Number(denominator);
-};
-harden(normalizedCollRatio);
-
-/**
- * Create a sort key for a normalized collateralization ratio. We want the key
- * to be based on a float with as much resolution as we can get, so we multiply
- * out the numerator and the denominator, and divide only once.
- *
- * @param {PriceQuote} quote
- * @param {Ratio} compoundedInterest
- * @param {Ratio} margin
- * @returns {string} lexically sortable string in which highest
- * debt-to-collateral is earliest
- */
-export const normalizedCollRatioKey = (quote, compoundedInterest, margin) => {
-  const collRatio = normalizedCollRatio(quote, compoundedInterest, margin);
-  return `${encodeNumber(collRatio)}:`;
-};
-harden(normalizedCollRatioKey);
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/type-imports.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/type-imports.js
deleted file mode 100644
index 5902add2f24..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/type-imports.js
+++ /dev/null
@@ -1,4 +0,0 @@
-// @jessie-check
-
-import '@agoric/zoe/exported.js';
-import './types.js';
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/types.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/types.js
deleted file mode 100644
index f7dd92a47a1..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/types.js
+++ /dev/null
@@ -1,134 +0,0 @@
-// @jessie-check
-
-/**
- * @typedef {import('./vault').VaultNotification} VaultNotification
- * @typedef {import('./vault').Vault} Vault
- * @typedef {import('./vaultKit').VaultKit} VaultKit
- * @typedef {import('./vaultManager').VaultManager} VaultManager
- * @typedef {import('./vaultManager').CollateralManager} CollateralManager
- * @typedef {import('@agoric/inter-protocol/src/reserve/assetReserve.js').AssetReserveLimitedCreatorFacet} AssetReserveCreatorFacet
- * @typedef {import('@agoric/inter-protocol/src/reserve/assetReserve.js').AssetReservePublicFacet} AssetReservePublicFacet
- * @typedef {import('@agoric/inter-protocol/src/auction/auctioneer.js').AuctioneerPublicFacet} AuctioneerPublicFacet
- * @typedef {import('./vaultFactory.js').VaultFactoryContract['publicFacet']} VaultFactoryPublicFacet
- *
- * @typedef {import('@agoric/time/src/types').Timestamp} Timestamp
- * @typedef {import('@agoric/time/src/types').RelativeTime} RelativeTime
- */
-
-/**
- * @typedef  {object} AutoswapLocal
- * @property {(amount: Amount, brand: Brand) => Amount} getInputPrice
- * @property {() => Invitation} makeSwapInvitation
- */
-
-/**
- * @typedef {object} VaultManagerParamValues
- * @property {Ratio} liquidationMargin - margin below which collateral will be
- * liquidated to satisfy the debt.
- * @property {Ratio} liquidationPenalty - penalty charged upon liquidation as proportion of debt
- * @property {Ratio} interestRate - annual interest rate charged on debt positions
- * @property {Ratio} mintFee - The fee (in BasisPoints) charged when creating
- * or increasing a debt position.
- * @property {Amount<'nat'>} debtLimit
- * @property {Ratio} [liquidationPadding] - vault must maintain this in order to remove collateral or add debt
- */
-
-/**
- * @callback AddVaultType
- * @param {Issuer} collateralIssuer
- * @param {Keyword} collateralKeyword
- * @param {VaultManagerParamValues} params
- * @returns {Promise<VaultManager>}
- */
-
-/**
- * @typedef  {object} VaultFactoryCreatorFacet
- * @property {AddVaultType} addVaultType
- * @property {() => Allocation} getRewardAllocation
- * @property {() => Promise<Invitation<string, never>>} makeCollectFeesInvitation
- * @property {() => import('@agoric/time/src/types').TimerWaker} makeLiquidationWaker
- * @property {() => import('@agoric/time/src/types').TimerWaker} makePriceLockWaker
- */
-
-/**
- * @callback MintAndTransfer
- * Mint new debt `toMint` and transfer the `fee` portion to the vaultFactory's reward
- * pool. Then reallocate over all the seat arguments and the rewardPoolSeat. Update
- * the `totalDebt` if the reallocate succeeds.
- * @param {ZCFSeat} mintReceiver
- * @param {Amount<'nat'>} toMint
- * @param {Amount<'nat'>} fee
- * @param {import('@agoric/zoe/src/contractSupport/atomicTransfer.js').TransferPart[]} transfers
- * @returns {void}
- */
-
-/**
- * @callback BurnDebt
- *
- * Burn debt tokens off a seat and update
- * the `totalDebt` if the reallocate succeeds.
- *
- * @param {Amount} toBurn
- * @param {ZCFSeat} fromSeat
- * @returns {void}
- */
-
-/**
- * @typedef {object} GetVaultParams
- * @property {() => Ratio} getLiquidationMargin
- * @property {() => Ratio} getMintFee
- * @property {() => Promise<PriceQuote>} getCollateralQuote
- * @property {() => Ratio} getInterestRate - The annual interest rate on a debt position
- * @property {() => RelativeTime} getChargingPeriod - The period (in seconds) at
- *   which interest is charged to the debt position.
- * @property {() => RelativeTime} getRecordingPeriod - The period (in seconds)
- *   at which interest is recorded to the debt position.
- */
-
-/**
- * @typedef {string} VaultId
- */
-
-/**
- * @typedef {object} InterestTiming
- * @property {RelativeTime} chargingPeriod in seconds
- * @property {RelativeTime} recordingPeriod in seconds
- */
-
-/**
- * @typedef {object} LiquidationStrategy
- * @property {() => KeywordKeywordRecord} keywordMapping
- * @property {(collateral: Amount, run: Amount) => Proposal} makeProposal
- * @property {(debt: Amount) => Promise<Invitation>} makeInvitation
- */
-
-/**
- * @typedef {object} Liquidator
- * @property {() => Promise<Invitation<void, { debt: Amount<'nat'>; penaltyRate: Ratio; }>>} makeLiquidateInvitation
- */
-
-/**
- * @typedef {object} DebtStatus
- * @property {Timestamp} latestInterestUpdate
- * @property {NatValue} interest interest accrued since latestInterestUpdate
- * @property {NatValue} newDebt total including principal and interest
- */
-
-/**
- * @callback Calculate
- * @param {DebtStatus} debtStatus
- * @param {Timestamp} currentTime
- * @returns {DebtStatus}
- */
-
-/**
- * @typedef {object} CalculatorKit
- * @property {Calculate} calculate calculate new debt for charging periods up to
- * the present.
- * @property {Calculate} calculateReportingPeriod calculate new debt for
- * reporting periods up to the present. If some charging periods have elapsed
- * that don't constitute whole reporting periods, the time is not updated past
- * them and interest is not accumulated for them.
- */
-
-/** @typedef {{key: 'governedParams' | {collateralBrand: Brand}}} VaultFactoryParamPath */
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vault.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vault.js
deleted file mode 100644
index 5dac1800b26..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vault.js
+++ /dev/null
@@ -1,874 +0,0 @@
-import { AmountMath, AmountShape } from '@agoric/ertp';
-import { makeTracer, StorageNodeShape } from '@agoric/internal';
-import { M, prepareExoClassKit } from '@agoric/vat-data';
-import { atomicTransfer } from '@agoric/zoe/src/contractSupport/index.js';
-import { SeatShape } from '@agoric/zoe/src/typeGuards.js';
-import {
-  addSubtract,
-  allEmpty,
-  makeNatAmountShape,
-} from '@agoric/inter-protocol/src/contractSupport.js';
-import {
-  calculateCurrentDebt,
-  reverseInterest,
-} from '@agoric/inter-protocol/src/interest-math.js';
-import { UnguardedHelperI } from '@agoric/inter-protocol/src/typeGuards.js';
-import { prepareVaultKit } from './vaultKit.js';
-
-import '@agoric/zoe/exported.js';
-import { calculateDebtCosts } from './math.js';
-
-const { quote: q, Fail } = assert;
-
-const trace = makeTracer('Vault', true);
-
-/** @typedef {import('./storeUtils.js').NormalizedDebt} NormalizedDebt */
-
-/**
- * @file This has most of the logic for a Vault, to borrow Minted against collateral.
- *
- * The logic here is for Vault which is the majority of logic of vaults but
- * the user view is the `vault` value contained in VaultKit.
- *
- * A note on naming convention:
- * - `Pre` is used as a postfix for any mutable value retrieved *before* an
- *    `await`, to flag values that must used very carefully after the `await`
- * - `new` is a prefix for values that describe the result of executing a
- *   transaction; e.g., `debt` is the value before the txn, and `newDebt`
- *   will be value if the txn completes.
- * - the absence of one of these implies the opposite, so `newDebt` is the
- *   future value fo `debt`, as computed based on values after any `await`
- */
-
-/**
- * Constants for vault phase.
- *
- * ACTIVE       - vault is in use and can be changed
- * LIQUIDATING  - vault is being liquidated by the vault manager, and cannot be changed by the user.
- *                If liquidation fails, vaults may remain in this state. An upgrade to the contract
- *                might be able to recover them.
- * TRANSFER     - vault is able to be transferred (payments and debits frozen until it has a new owner)
- * CLOSED       - vault was closed by the user and all assets have been paid out
- * LIQUIDATED   - vault was closed by the manager, with remaining assets paid to owner
- */
-export const Phase = /** @type {const} */ ({
-  ACTIVE: 'active',
-  LIQUIDATING: 'liquidating',
-  CLOSED: 'closed',
-  LIQUIDATED: 'liquidated',
-  TRANSFER: 'transfer',
-});
-
-/**
- * @typedef {Phase[keyof Omit<typeof Phase, 'TRANSFER'>]} VaultPhase
- * @type {{[K in VaultPhase]: Array<VaultPhase>}}
- */
-const validTransitions = {
-  [Phase.ACTIVE]: [Phase.LIQUIDATING, Phase.CLOSED],
-  [Phase.LIQUIDATING]: [Phase.LIQUIDATED, Phase.ACTIVE],
-  [Phase.LIQUIDATED]: [Phase.CLOSED],
-  [Phase.CLOSED]: [],
-};
-
-/**
- * @typedef {Phase[keyof typeof Phase]} HolderPhase
- *
- * @typedef {object} VaultNotification
- * @property {Amount<'nat'>} locked Amount of Collateral locked
- * @property {{debt: Amount<'nat'>, interest: Ratio}} debtSnapshot 'debt' at the point the compounded interest was 'interest'
- * @property {HolderPhase} vaultState
- */
-
-// XXX masks typedef from types.js, but using that causes circular def problems
-/**
- * @typedef {object} VaultManager
- * @property {() => Subscriber<import('./vaultManager').AssetState>} getAssetSubscriber
- * @property {(collateralAmount: Amount) => Amount<'nat'>} maxDebtFor
- * @property {() => Brand} getCollateralBrand
- * @property {(base: string) => string} scopeDescription
- * @property {() => Brand<'nat'>} getDebtBrand
- * @property {MintAndTransfer} mintAndTransfer
- * @property {(amount: Amount, seat: ZCFSeat) => void} burn
- * @property {() => Ratio} getCompoundedInterest
- * @property {(oldDebt: import('./storeUtils.js').NormalizedDebt, oldCollateral: Amount<'nat'>, vaultId: VaultId, vaultPhase: VaultPhase, vault: Vault) => void} handleBalanceChange
- * @property {() => import('./vaultManager.js').GovernedParamGetters} getGovernedParams
- */
-
-/**
- * @typedef {Readonly<{
- * idInManager: VaultId,
- * manager: VaultManager,
- * storageNode: StorageNode,
- * vaultSeat: ZCFSeat,
- * }>} ImmutableState
- */
-
-/**
- * Snapshot is of the debt and compounded interest when the principal was last changed.
- *
- * @typedef {{
- *   interestSnapshot: Ratio,
- *   phase: VaultPhase,
- *   debtSnapshot: Amount<'nat'>,
- *   outerUpdater: import('@agoric/zoe/src/contractSupport/recorder.js').Recorder<VaultNotification> | null,
- * }} MutableState
- */
-
-export const VaultI = M.interface('Vault', {
-  getCollateralAmount: M.call().returns(AmountShape),
-  getCurrentDebt: M.call().returns(AmountShape),
-  getNormalizedDebt: M.call().returns(AmountShape),
-  getVaultSeat: M.call().returns(SeatShape),
-  initVaultKit: M.call(SeatShape, StorageNodeShape).returns(M.promise()),
-  liquidated: M.call().returns(undefined),
-  liquidating: M.call().returns(undefined),
-  makeAdjustBalancesInvitation: M.call().returns(M.promise()),
-  makeCloseInvitation: M.call().returns(M.promise()),
-  makeTransferInvitation: M.call().returns(M.promise()),
-  abortLiquidation: M.call().returns(M.string()),
-});
-
-const VaultStateShape = harden({
-  idInManager: M.any(),
-  manager: M.any(),
-  outerUpdater: M.any(),
-  phase: M.any(),
-  storageNode: M.any(),
-  vaultSeat: M.any(),
-  interestSnapshot: M.any(),
-  debtSnapshot: M.any(),
-});
-
-/**
- * @param {import('@agoric/ertp').Baggage} baggage
- * @param {import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit} makeRecorderKit
- * @param {ZCF} zcf
- */
-export const prepareVault = (baggage, makeRecorderKit, zcf) => {
-  const makeVaultKit = prepareVaultKit(baggage, makeRecorderKit);
-
-  const maker = prepareExoClassKit(
-    baggage,
-    'Vault',
-    {
-      helper: UnguardedHelperI,
-      self: VaultI,
-    },
-    /**
-     * @param {VaultManager} manager
-     * @param {VaultId} idInManager
-     * @param {StorageNode} storageNode
-     * @returns {ImmutableState & MutableState}
-     */
-    (manager, idInManager, storageNode) => {
-      return harden({
-        idInManager,
-        manager,
-        outerUpdater: null,
-        phase: Phase.ACTIVE,
-
-        storageNode,
-
-        // vaultSeat will hold the collateral until the position is retired. The
-        // payout from it will be handed to the user: if the vault dies early
-        // (because the vaultFactory vat died), they'll get all their
-        // collateral back. If that happens, the issuer for the Minted will be dead,
-        // so their position will be worthless.
-        vaultSeat: zcf.makeEmptySeatKit().zcfSeat,
-
-        // Two values from the same moment
-        interestSnapshot: manager.getCompoundedInterest(),
-        debtSnapshot: AmountMath.makeEmpty(manager.getDebtBrand()),
-      });
-    },
-    {
-      helper: {
-        //#region Computed constants
-        collateralBrand() {
-          return this.state.manager.getCollateralBrand();
-        },
-        debtBrand() {
-          return this.state.manager.getDebtBrand();
-        },
-
-        emptyCollateral() {
-          return AmountMath.makeEmpty(this.facets.helper.collateralBrand());
-        },
-        emptyDebt() {
-          return AmountMath.makeEmpty(this.facets.helper.debtBrand());
-        },
-        /**
-         * @typedef {{ give: { Collateral: Amount<'nat'>, Minted: Amount<'nat'> }, want: { Collateral: Amount<'nat'>, Minted: Amount<'nat'> } }} FullProposal
-         */
-        /**
-         * @param {ProposalRecord} partial
-         * @returns {FullProposal}
-         */
-        fullProposal(partial) {
-          return {
-            give: {
-              Collateral:
-                partial.give?.Collateral ||
-                this.facets.helper.emptyCollateral(),
-              Minted: partial.give?.Minted || this.facets.helper.emptyDebt(),
-            },
-            want: {
-              Collateral:
-                partial.want?.Collateral ||
-                this.facets.helper.emptyCollateral(),
-              Minted: partial.want?.Minted || this.facets.helper.emptyDebt(),
-            },
-          };
-        },
-        //#endregion
-
-        //#region Phase logic
-        /**
-         * @param {VaultPhase} newPhase
-         */
-        assignPhase(newPhase) {
-          const { state } = this;
-
-          const { phase } = state;
-          const validNewPhases = validTransitions[phase];
-          validNewPhases.includes(newPhase) ||
-            Fail`Vault cannot transition from ${q(phase)} to ${q(newPhase)}`;
-          state.phase = newPhase;
-        },
-
-        assertActive() {
-          const { phase } = this.state;
-          phase === Phase.ACTIVE || Fail`vault not active`;
-        },
-
-        assertCloseable() {
-          const { phase } = this.state;
-          phase === Phase.ACTIVE ||
-            phase === Phase.LIQUIDATED ||
-            Fail`to be closed a vault must be active or liquidated, not ${phase}`;
-        },
-        //#endregion
-
-        /**
-         * Called whenever the debt is paid or created through a transaction,
-         * but not for interest accrual.
-         *
-         * @param {Amount<'nat'>} newDebt - principal and all accrued interest
-         */
-        updateDebtSnapshot(newDebt) {
-          const { state } = this;
-
-          // update local state
-          state.debtSnapshot = newDebt;
-          state.interestSnapshot = state.manager.getCompoundedInterest();
-        },
-
-        /**
-         * Update the debt balance and propagate upwards to
-         * maintain aggregate debt and liquidation order.
-         *
-         * @param {NormalizedDebt} oldDebtNormalized - prior principal and all accrued interest, normalized to the launch of the vaultManager
-         * @param {Amount<'nat'>} oldCollateral - actual collateral
-         * @param {Amount<'nat'>} newDebtActual - actual principal and all accrued interest
-         */
-        updateDebtAccounting(oldDebtNormalized, oldCollateral, newDebtActual) {
-          const { state, facets } = this;
-          const { helper } = facets;
-          helper.updateDebtSnapshot(newDebtActual);
-          // notify manager so it can notify and clean up as appropriate
-          state.manager.handleBalanceChange(
-            oldDebtNormalized,
-            oldCollateral,
-            state.idInManager,
-            state.phase,
-            facets.self,
-          );
-        },
-
-        /**
-         *
-         * @param {ZCFSeat} seat
-         */
-        getCollateralAllocated(seat) {
-          return seat.getAmountAllocated(
-            'Collateral',
-            this.facets.helper.collateralBrand(),
-          );
-        },
-        getMintedAllocated(seat) {
-          return seat.getAmountAllocated(
-            'Minted',
-            this.facets.helper.debtBrand(),
-          );
-        },
-
-        assertVaultHoldsNoMinted() {
-          const { state, facets } = this;
-          const { vaultSeat } = state;
-          AmountMath.isEmpty(facets.helper.getMintedAllocated(vaultSeat)) ||
-            Fail`Vault should be empty of Minted`;
-        },
-
-        /**
-         *
-         * @param {Amount<'nat'>} collateralAmount
-         * @param {Amount<'nat'>} proposedDebt
-         */
-        assertSufficientCollateral(collateralAmount, proposedDebt) {
-          const { state, facets } = this;
-          const maxDebt = state.manager.maxDebtFor(collateralAmount);
-          AmountMath.isGTE(maxDebt, proposedDebt, facets.helper.debtBrand()) ||
-            Fail`Proposed debt ${q(proposedDebt)} exceeds max ${q(
-              maxDebt,
-            )} for ${q(collateralAmount)} collateral`;
-        },
-
-        /**
-         *
-         * @param {HolderPhase} newPhase
-         */
-        getStateSnapshot(newPhase) {
-          const { state, facets } = this;
-
-          const { debtSnapshot: debt, interestSnapshot: interest } = state;
-          /** @type {VaultNotification} */
-          return harden({
-            debtSnapshot: { debt, interest },
-            locked: facets.self.getCollateralAmount(),
-            // newPhase param is so that makeTransferInvitation can finish without setting the vault's phase
-            // TODO refactor https://github.com/Agoric/agoric-sdk/issues/4415
-            vaultState: newPhase,
-          });
-        },
-
-        /**
-         * call this whenever anything changes!
-         */
-        updateUiState() {
-          const { state, facets } = this;
-          const { outerUpdater } = state;
-          if (!outerUpdater) {
-            // It's not an error to change to liquidating during transfer
-            return;
-          }
-          const { phase } = state;
-          const uiState = facets.helper.getStateSnapshot(phase);
-          const brand = facets.helper.collateralBrand();
-          trace(brand, 'updateUiState', state.idInManager, uiState);
-
-          switch (phase) {
-            case Phase.ACTIVE:
-            case Phase.LIQUIDATING:
-            case Phase.LIQUIDATED:
-              void outerUpdater.write(uiState);
-              break;
-            case Phase.CLOSED:
-              void outerUpdater.writeFinal(uiState);
-              state.outerUpdater = null;
-              break;
-            default:
-              throw Error(`unreachable vault phase: ${phase}`);
-          }
-        },
-
-        /**
-         * @param {ZCFSeat} seat
-         */
-        async closeHook(seat) {
-          const { state, facets } = this;
-
-          const { self, helper } = facets;
-          helper.assertCloseable();
-          const { phase, vaultSeat } = state;
-
-          // Held as keys for cleanup in the manager
-          const oldDebtNormalized = self.getNormalizedDebt();
-          const oldCollateral = self.getCollateralAmount();
-
-          if (phase === Phase.ACTIVE) {
-            // you're paying off the debt, you get everything back.
-            const debt = self.getCurrentDebt();
-            const {
-              give: { Minted: given },
-            } = seat.getProposal();
-            given || Fail`closing an active vault requires a give`;
-
-            // you must pay off the entire remainder but if you offer too much, we won't
-            // take more than you owe
-            AmountMath.isGTE(given, debt) ||
-              Fail`Offer ${q(given)} is not sufficient to pay off debt ${q(
-                debt,
-              )}`;
-
-            // Return any overpayment
-            atomicTransfer(
-              zcf,
-              vaultSeat,
-              seat,
-              vaultSeat.getCurrentAllocation(),
-            );
-
-            state.manager.burn(debt, seat);
-          } else if (phase === Phase.LIQUIDATED) {
-            // Simply reallocate vault assets to the offer seat.
-            // Don't take anything from the offer, even if vault is underwater.
-            // TODO verify that returning Minted here doesn't mess up debt limits
-
-            atomicTransfer(
-              zcf,
-              vaultSeat,
-              seat,
-              vaultSeat.getCurrentAllocation(),
-            );
-          } else {
-            throw Error('only active and liquidated vaults can be closed');
-          }
-
-          seat.exit();
-          helper.assignPhase(Phase.CLOSED);
-          helper.updateDebtSnapshot(helper.emptyDebt());
-          helper.updateUiState();
-          helper.assertVaultHoldsNoMinted();
-          vaultSeat.exit();
-
-          state.manager.handleBalanceChange(
-            oldDebtNormalized,
-            oldCollateral,
-            state.idInManager,
-            state.phase,
-            facets.self,
-          );
-
-          return 'your vault is closed, thank you for your business';
-        },
-
-        /**
-         * Calculate the fee, the amount to mint and the resulting debt.
-         * The give and the want together reflect a delta, where typically
-         * one is zero because they come from the gave/want of an offer
-         * proposal. If the `want` is zero, the `fee` will also be zero,
-         * so the simple math works.
-         *
-         * @param {Amount<'nat'>} currentDebt
-         * @param {Amount<'nat'>} giveAmount
-         * @param {Amount<'nat'>} wantAmount
-         */
-        debtFee(currentDebt, giveAmount, wantAmount) {
-          const { state } = this;
-
-          return calculateDebtCosts(
-            currentDebt,
-            giveAmount,
-            wantAmount,
-            state.manager.getGovernedParams().getMintFee(),
-          );
-        },
-
-        /**
-         * Adjust principal and collateral (atomically for offer safety)
-         *
-         * @param {ZCFSeat} clientSeat
-         * @returns {string} success message
-         */
-        adjustBalancesHook(clientSeat) {
-          const { state, facets } = this;
-
-          const { self, helper } = facets;
-          const { vaultSeat } = state;
-          const fp = helper.fullProposal(clientSeat.getProposal());
-
-          if (
-            allEmpty([
-              fp.give.Collateral,
-              fp.give.Minted,
-              fp.want.Collateral,
-              fp.want.Minted,
-            ])
-          ) {
-            clientSeat.exit();
-            return 'no transaction, as requested';
-          }
-
-          // Calculate the fee, the amount to mint and the resulting debt. We'll
-          // verify that the target debt doesn't violate the collateralization ratio,
-          // then mint, reallocate, and burn.
-          const { newDebt, fee, surplus, toMint } = helper.debtFee(
-            self.getCurrentDebt(),
-            fp.give.Minted,
-            fp.want.Minted,
-          );
-
-          const normalizedDebtPre = self.getNormalizedDebt();
-          const collateralPre = helper.getCollateralAllocated(vaultSeat);
-
-          const hasWants = !allEmpty([fp.want.Collateral, fp.want.Minted]);
-          if (hasWants) {
-            const newCollateral = addSubtract(
-              collateralPre,
-              fp.give.Collateral,
-              fp.want.Collateral,
-            );
-            helper.assertSufficientCollateral(newCollateral, newDebt);
-          }
-
-          return helper.commitBalanceAdjustment(
-            clientSeat,
-            fp,
-            {
-              newDebt,
-              fee,
-              surplus,
-              toMint,
-            },
-            { normalizedDebtPre, collateralPre },
-          );
-        },
-
-        /**
-         *
-         * @param {ZCFSeat} clientSeat
-         * @param {FullProposal} fp
-         * @param {ReturnType<typeof calculateDebtCosts>} costs
-         * @param {object} accounting
-         * @param {NormalizedDebt} accounting.normalizedDebtPre
-         * @param {Amount<'nat'>} accounting.collateralPre
-         * @returns {string} success message
-         */
-        commitBalanceAdjustment(
-          clientSeat,
-          fp,
-          { newDebt, fee, surplus, toMint },
-          { normalizedDebtPre, collateralPre },
-        ) {
-          const { state, facets } = this;
-          const { helper } = facets;
-          const { vaultSeat } = state;
-
-          const giveMintedTaken = AmountMath.subtract(fp.give.Minted, surplus);
-
-          /** @type {import('@agoric/zoe/src/contractSupport/atomicTransfer.js').TransferPart[]} */
-          const transfers = harden([
-            [clientSeat, vaultSeat, { Collateral: fp.give.Collateral }],
-            [vaultSeat, clientSeat, { Collateral: fp.want.Collateral }],
-            [clientSeat, vaultSeat, { Minted: giveMintedTaken }],
-            // Minted into vaultSeat requires minting and so is done by mintAndTransfer
-          ]);
-
-          state.manager.mintAndTransfer(clientSeat, toMint, fee, transfers);
-
-          // parent needs to know about the change in debt
-          helper.updateDebtAccounting(
-            normalizedDebtPre,
-            collateralPre,
-            newDebt,
-          );
-          state.manager.burn(giveMintedTaken, vaultSeat);
-          helper.assertVaultHoldsNoMinted();
-
-          helper.updateUiState();
-          clientSeat.exit();
-          return 'We have adjusted your balances, thank you for your business';
-        },
-
-        /**
-         *
-         * @param {ZCFSeat} seat
-         * @returns {VaultKit}
-         */
-        makeTransferInvitationHook(seat) {
-          const { state, facets } = this;
-
-          const { self, helper } = facets;
-          helper.assertCloseable();
-          seat.exit();
-
-          // eslint-disable-next-line no-use-before-define
-          const vaultKit = makeVaultKit(self, state.storageNode);
-          state.outerUpdater = vaultKit.vaultUpdater;
-          helper.updateUiState();
-
-          return vaultKit;
-        },
-      },
-      self: {
-        getVaultSeat() {
-          return this.state.vaultSeat;
-        },
-
-        /**
-         * @param {ZCFSeat} seat
-         * @param {StorageNode} storageNode
-         */
-        async initVaultKit(seat, storageNode) {
-          const { state, facets } = this;
-
-          const { self, helper } = facets;
-
-          const normalizedDebtPre = self.getNormalizedDebt();
-          const actualDebtPre = self.getCurrentDebt();
-          (AmountMath.isEmpty(normalizedDebtPre) &&
-            AmountMath.isEmpty(actualDebtPre)) ||
-            Fail`vault must be empty initially`;
-
-          const collateralPre = self.getCollateralAmount();
-          trace('initVaultKit start: collateral', state.idInManager, {
-            actualDebtPre,
-            collateralPre,
-          });
-
-          // get the payout to provide access to the collateral if the
-          // contract abandons
-          const {
-            give: { Collateral: giveCollateral },
-            want: { Minted: wantMinted },
-          } = seat.getProposal();
-
-          const minInitialDebt = state.manager
-            .getGovernedParams()
-            .getMinInitialDebt();
-          AmountMath.isGTE(wantMinted, minInitialDebt) ||
-            Fail`Vault creation requires a minInitialDebt of ${q(
-              minInitialDebt,
-            )}`;
-
-          const {
-            newDebt: newDebtPre,
-            fee,
-            toMint,
-          } = helper.debtFee(actualDebtPre, helper.emptyDebt(), wantMinted);
-          !AmountMath.isEmpty(fee) ||
-            Fail`debt requested (${wantMinted}) too small to accrue interest`;
-          AmountMath.isEqual(newDebtPre, toMint) ||
-            Fail`fee mismatch for vault`;
-          trace(
-            'initVault',
-            state.idInManager,
-            { wantedRun: wantMinted, fee },
-            self.getCollateralAmount(),
-          );
-
-          helper.assertSufficientCollateral(giveCollateral, newDebtPre);
-
-          const { vaultSeat } = state;
-          state.manager.mintAndTransfer(
-            seat,
-            toMint,
-            fee,
-            harden([[seat, vaultSeat, { Collateral: giveCollateral }]]),
-          );
-          seat.exit();
-
-          helper.updateDebtAccounting(
-            normalizedDebtPre,
-            collateralPre,
-            newDebtPre,
-          );
-          trace('initVault updateDebtAccounting fired');
-
-          // So that makeVaultKit can be synchronous
-          const vaultKit = makeVaultKit(self, storageNode);
-          state.outerUpdater = vaultKit.vaultUpdater;
-          helper.updateUiState();
-          return vaultKit;
-        },
-
-        /**
-         * Called by manager at start of liquidation.
-         */
-        liquidating() {
-          const { facets } = this;
-
-          const { helper } = facets;
-          helper.assignPhase(Phase.LIQUIDATING);
-          helper.updateUiState();
-        },
-
-        /**
-         * Called by manager at end of liquidation, at which point all debts have been
-         * covered.
-         */
-        liquidated() {
-          const { facets } = this;
-
-          const { helper } = facets;
-          helper.updateDebtSnapshot(
-            // liquidated vaults retain no debt
-            AmountMath.makeEmpty(helper.debtBrand()),
-          );
-
-          helper.assignPhase(Phase.LIQUIDATED);
-          helper.updateUiState();
-        },
-
-        /**
-         * Called by vaultManager when the auction wasn't able to sell the
-         * collateral. The liquidation fee was charged against the collateral,
-         * but the debt will be restored and the vault will be active again.
-         * Liquidation.md has details on the liquidation approach.
-         */
-        abortLiquidation() {
-          const { state, facets } = this;
-
-          const { helper } = facets;
-
-          helper.assignPhase(Phase.ACTIVE);
-          helper.updateUiState();
-          return state.idInManager;
-        },
-
-        makeAdjustBalancesInvitation() {
-          const { state, facets } = this;
-          const { helper } = facets;
-          helper.assertActive();
-
-          return zcf.makeInvitation(
-            seat => helper.adjustBalancesHook(seat),
-            state.manager.scopeDescription('AdjustBalances'),
-            undefined,
-            M.splitRecord({
-              give: M.splitRecord(
-                {},
-                {
-                  // It may seem odd to give both at once but there is use case:
-                  // To rescue a vault that's on the verge of being liquidated
-                  // when you have limited resources, you might add collateral
-                  // at the same time that you're repaying IST.
-                  Collateral: makeNatAmountShape(helper.collateralBrand()),
-                  Minted: makeNatAmountShape(helper.debtBrand()),
-                },
-                {},
-              ),
-              want: M.splitRecord(
-                {},
-                {
-                  Collateral: makeNatAmountShape(helper.collateralBrand()),
-                  Minted: makeNatAmountShape(helper.debtBrand()),
-                },
-                {},
-              ),
-            }),
-          );
-        },
-
-        makeCloseInvitation() {
-          const { state, facets } = this;
-          const { helper } = facets;
-          helper.assertCloseable();
-          return zcf.makeInvitation(
-            seat => helper.closeHook(seat),
-            state.manager.scopeDescription('CloseVault'),
-            undefined,
-            M.splitRecord({
-              give: M.splitRecord(
-                {},
-                {
-                  Minted: makeNatAmountShape(helper.debtBrand()),
-                },
-                {},
-              ),
-              want: M.splitRecord(
-                {},
-                {
-                  Collateral: makeNatAmountShape(helper.collateralBrand()),
-                },
-                {},
-              ),
-            }),
-          );
-        },
-
-        /**
-         * @returns {Promise<Invitation>}
-         */
-        makeTransferInvitation() {
-          const { state, facets } = this;
-          const { outerUpdater } = state;
-          const { self, helper } = facets;
-          // Bring the debt snapshot current for the final report before transfer
-          helper.updateDebtSnapshot(self.getCurrentDebt());
-          const {
-            debtSnapshot: debt,
-            interestSnapshot: interest,
-            phase,
-          } = state;
-          if (outerUpdater) {
-            void outerUpdater.writeFinal(
-              helper.getStateSnapshot(Phase.TRANSFER),
-            );
-            state.outerUpdater = null;
-          }
-          const transferState = {
-            debtSnapshot: { debt, interest },
-            locked: self.getCollateralAmount(),
-            vaultState: phase,
-          };
-          return zcf.makeInvitation(
-            seat => helper.makeTransferInvitationHook(seat),
-            state.manager.scopeDescription('TransferVault'),
-            transferState,
-          );
-        },
-
-        // for status/debugging
-
-        /**
-         *
-         * @returns {Amount<'nat'>}
-         */
-        getCollateralAmount() {
-          const { state, facets } = this;
-          const { vaultSeat } = state;
-          const { helper } = facets;
-          // getCollateralAllocated would return final allocations
-          return vaultSeat.hasExited()
-            ? helper.emptyCollateral()
-            : helper.getCollateralAllocated(vaultSeat);
-        },
-
-        /**
-         * The actual current debt, including accrued interest.
-         *
-         * This looks like a simple getter but it does a lot of the heavy lifting for
-         * interest accrual. Rather than updating all records when interest accrues,
-         * the vault manager updates just its rolling compounded interest. Here we
-         * calculate what the current debt is given what's recorded in this vault and
-         * what interest has compounded since this vault record was written.
-         *
-         * @see getNormalizedDebt
-         *
-         * @returns {Amount<'nat'>}
-         */
-        getCurrentDebt() {
-          const { state } = this;
-          return calculateCurrentDebt(
-            state.debtSnapshot,
-            state.interestSnapshot,
-            state.manager.getCompoundedInterest(),
-          );
-        },
-
-        /**
-         * The normalization puts all debts on a common time-independent scale since
-         * the launch of this vault manager. This allows the manager to order vaults
-         * by their debt-to-collateral ratios without having to mutate the debts as
-         * the interest accrues.
-         *
-         * @see getActualDebAmount
-         *
-         * @returns {import('./storeUtils.js').NormalizedDebt} as if the vault was open at the launch of this manager, before any interest accrued
-         */
-        getNormalizedDebt() {
-          const { state } = this;
-          // @ts-expect-error cast
-          return reverseInterest(state.debtSnapshot, state.interestSnapshot);
-        },
-      },
-    },
-    {
-      stateShape: VaultStateShape,
-    },
-  );
-  return maker;
-};
-
-/** @typedef {ReturnType<ReturnType<typeof prepareVault>>['self']} Vault */
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultDirector.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultDirector.js
deleted file mode 100644
index 55f5808acd5..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultDirector.js
+++ /dev/null
@@ -1,537 +0,0 @@
-import '@agoric/zoe/exported.js';
-import '@agoric/zoe/src/contracts/exported.js';
-
-import '@agoric/governance/exported.js';
-
-import { AmountMath, AmountShape, BrandShape, IssuerShape } from '@agoric/ertp';
-import { GovernorFacetShape } from '@agoric/governance/src/typeGuards.js';
-import { makeTracer } from '@agoric/internal';
-import { M, mustMatch } from '@agoric/store';
-import {
-  prepareExoClassKit,
-  provide,
-  provideDurableMapStore,
-} from '@agoric/vat-data';
-import { assertKeywordName } from '@agoric/zoe/src/cleanProposal.js';
-import {
-  atomicRearrange,
-  makeRecorderTopic,
-  provideEmptySeat,
-  SubscriberShape,
-  TopicsRecordShape,
-  unitAmount,
-} from '@agoric/zoe/src/contractSupport/index.js';
-import { E } from '@endo/eventual-send';
-import { Far } from '@endo/marshal';
-import { makeCollectFeesInvitation } from '@agoric/inter-protocol/src/collectFees.js';
-import {
-  setWakeupsForNextAuction,
-  watchForGovernanceChange,
-} from './liquidation.js';
-import {
-  provideVaultParamManagers,
-  SHORTFALL_INVITATION_KEY,
-  vaultParamPattern,
-} from './params.js';
-import {
-  prepareVaultManagerKit,
-  provideAndStartVaultManagerKits,
-} from './vaultManager.js';
-
-const { Fail, quote: q } = assert;
-
-const trace = makeTracer('VD', true);
-
-/**
- * @typedef {{
- * collaterals: Brand[],
- * rewardPoolAllocation: AmountKeywordRecord,
- * }} MetricsNotification
- *
- * @typedef {Readonly<{
- * }>} ImmutableState
- *
- * @typedef {{
- * }} MutableState
- *
- * @typedef {ImmutableState & MutableState} State
- *
- * @typedef {{
- *  burnDebt: BurnDebt,
- *  getGovernedParams: (collateralBrand: Brand) => import('./vaultManager.js').GovernedParamGetters,
- *  mintAndTransfer: MintAndTransfer,
- *  getShortfallReporter: () => Promise<import('@agoric/inter-protocol/src/reserve/assetReserve.js').ShortfallReporter>,
- * }} FactoryPowersFacet
- *
- * @typedef {Readonly<{
- *   state: State;
- * }>} MethodContext
- *
- * @typedef {import('@agoric/governance/src/contractGovernance/typedParamManager').TypedParamManager<import('./params.js').VaultDirectorParams>} VaultDirectorParamManager
- */
-
-const shortfallInvitationKey = 'shortfallInvitation';
-
-/**
- * @param {import('@agoric/ertp').Baggage} baggage
- * @param {import('./vaultFactory.js').VaultFactoryZCF} zcf
- * @param {VaultDirectorParamManager} directorParamManager
- * @param {ZCFMint<"nat">} debtMint
- * @param {ERef<import('@agoric/time/src/types').TimerService>} timer
- * @param {ERef<import('@agoric/inter-protocol/src/auction/auctioneer.js').AuctioneerPublicFacet>} auctioneer
- * @param {ERef<StorageNode>} storageNode
- * @param {ERef<Marshaller>} marshaller
- * @param {import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit} makeRecorderKit
- * @param {import('@agoric/zoe/src/contractSupport/recorder.js').MakeERecorderKit} makeERecorderKit
- */
-const prepareVaultDirector = (
-  baggage,
-  zcf,
-  directorParamManager,
-  debtMint,
-  timer,
-  auctioneer,
-  storageNode,
-  marshaller,
-  makeRecorderKit,
-  makeERecorderKit,
-) => {
-  /** @type {import('@agoric/inter-protocol/src/reserve/assetReserve.js').ShortfallReporter} */
-  let shortfallReporter;
-
-  /** For holding newly minted tokens until transferred */
-  const { zcfSeat: mintSeat } = zcf.makeEmptySeatKit();
-
-  const rewardPoolSeat = provideEmptySeat(zcf, baggage, 'rewardPoolSeat');
-
-  /** @type {MapStore<Brand, number>} index of manager for the given collateral */
-  const collateralManagers = provideDurableMapStore(
-    baggage,
-    'collateralManagers',
-  );
-
-  // Non-durable map because param managers aren't durable.
-  // In the event they're needed they can be reconstructed from contract terms and off-chain data.
-  /** a powerful object; can modify parameters */
-  const vaultParamManagers = provideVaultParamManagers(baggage, marshaller);
-
-  const metricsNode = E(storageNode).makeChildNode('metrics');
-
-  const metricsKit = makeERecorderKit(
-    metricsNode,
-    /** @type {import('@agoric/zoe/src/contractSupport/recorder.js').TypedMatcher<MetricsNotification>} */ (
-      M.any()
-    ),
-  );
-
-  const managersNode = E(storageNode).makeChildNode('managers');
-
-  /**
-   * @returns {MetricsNotification}
-   */
-  const sampleMetrics = () => {
-    return harden({
-      collaterals: Array.from(collateralManagers.keys()),
-      rewardPoolAllocation: rewardPoolSeat.getCurrentAllocation(),
-    });
-  };
-  const writeMetrics = () => E(metricsKit.recorderP).write(sampleMetrics());
-
-  const updateShortfallReporter = async () => {
-    const oldInvitation = baggage.has(shortfallInvitationKey)
-      ? baggage.get(shortfallInvitationKey)
-      : undefined;
-    const newInvitation = await directorParamManager.getInternalParamValue(
-      SHORTFALL_INVITATION_KEY,
-    );
-
-    if (newInvitation === oldInvitation) {
-      shortfallReporter ||
-        Fail`updateShortFallReported called with repeat invitation and no prior shortfallReporter`;
-      return;
-    }
-
-    // Update the values
-    const zoe = zcf.getZoeService();
-    // @ts-expect-error cast
-    shortfallReporter = E(E(zoe).offer(newInvitation)).getOfferResult();
-    if (oldInvitation === undefined) {
-      baggage.init(shortfallInvitationKey, newInvitation);
-    } else {
-      baggage.set(shortfallInvitationKey, newInvitation);
-    }
-  };
-
-  const factoryPowers = Far('vault factory powers', {
-    /**
-     * Get read-only params for this manager and its director. This grants all
-     * managers access to params from all managers. It's not POLA but it's a
-     * public authority and it reduces the number of distinct power objects to
-     * create.
-     *
-     * @param {Brand} brand
-     */
-    getGovernedParams: brand => {
-      const vaultParamManager = vaultParamManagers.get(brand);
-      return Far('vault manager param manager', {
-        // merge director and manager params
-        ...directorParamManager.readonly(),
-        ...vaultParamManager.readonly(),
-        // redeclare these getters as to specify the kind of the Amount
-        getMinInitialDebt: /** @type {() => Amount<'nat'>} */ (
-          directorParamManager.readonly().getMinInitialDebt
-        ),
-        getDebtLimit: /** @type {() => Amount<'nat'>} */ (
-          vaultParamManager.readonly().getDebtLimit
-        ),
-      });
-    },
-
-    /**
-     * Let the manager add rewards to the rewardPoolSeat without
-     * exposing the rewardPoolSeat to them.
-     *
-     * @type {MintAndTransfer}
-     */
-    mintAndTransfer: (mintReceiver, toMint, fee, nonMintTransfers) => {
-      const kept = AmountMath.subtract(toMint, fee);
-      debtMint.mintGains(harden({ Minted: toMint }), mintSeat);
-      /** @type {import('@agoric/zoe/src/contractSupport/atomicTransfer.js').TransferPart[]} */
-      const transfers = [
-        ...nonMintTransfers,
-        [mintSeat, rewardPoolSeat, { Minted: fee }],
-        [mintSeat, mintReceiver, { Minted: kept }],
-      ];
-      try {
-        atomicRearrange(zcf, harden(transfers));
-      } catch (e) {
-        console.error('mintAndTransfer failed to rearrange', e);
-        // If the rearrange fails, burn the newly minted tokens.
-        // Assume this won't fail because it relies on the internal mint.
-        // (Failure would imply much larger problems.)
-        debtMint.burnLosses(harden({ Minted: toMint }), mintSeat);
-        throw e;
-      }
-      void writeMetrics();
-    },
-    getShortfallReporter: async () => {
-      await updateShortfallReporter();
-      return shortfallReporter;
-    },
-    /**
-     * @param {Amount<'nat'>} toBurn
-     * @param {ZCFSeat} seat
-     */
-    burnDebt: (toBurn, seat) => {
-      debtMint.burnLosses(harden({ Minted: toBurn }), seat);
-    },
-  });
-
-  const makeVaultManagerKit = prepareVaultManagerKit(baggage, {
-    makeERecorderKit,
-    makeRecorderKit,
-    marshaller,
-    factoryPowers,
-    zcf,
-  });
-
-  const vaultManagers = provideAndStartVaultManagerKits(baggage);
-
-  /** @type {(brand: Brand) => VaultManager} */
-  const managerForCollateral = brand => {
-    const managerIndex = collateralManagers.get(brand);
-    const manager = vaultManagers.get(managerIndex).self;
-    manager || Fail`no manager ${managerIndex} for collateral ${brand}`;
-    return manager;
-  };
-
-  // TODO helper to make all the topics at once
-  const topics = harden({
-    metrics: makeRecorderTopic('Vault Factory metrics', metricsKit),
-  });
-
-  const allManagersDo = fn => {
-    for (const managerIndex of collateralManagers.values()) {
-      const vm = vaultManagers.get(managerIndex).self;
-      fn(vm);
-    }
-  };
-
-  const makeWaker = (name, func) => {
-    return Far(name, {
-      wake: timestamp => func(timestamp),
-    });
-  };
-
-  /**
-   * @returns {State}
-   */
-  const initState = () => {
-    return {};
-  };
-
-  /**
-   * "Director" of the vault factory, overseeing "vault managers".
-   *
-   * @param {import('./vaultFactory.js').VaultFactoryZCF} zcf
-   * @param {VaultDirectorParamManager} directorParamManager
-   * @param {ZCFMint<"nat">} debtMint
-   */
-  const makeVaultDirector = prepareExoClassKit(
-    baggage,
-    'VaultDirector',
-    {
-      creator: M.interface('creator', {
-        ...GovernorFacetShape,
-      }),
-      machine: M.interface('machine', {
-        addVaultType: M.call(IssuerShape, M.string(), M.record()).returns(
-          M.promise(),
-        ),
-        makeCollectFeesInvitation: M.call().returns(M.promise()),
-        getRewardAllocation: M.call().returns({ Minted: AmountShape }),
-        makePriceLockWaker: M.call().returns(M.remotable('TimerWaker')),
-        makeLiquidationWaker: M.call().returns(M.remotable('TimerWaker')),
-        makeReschedulerWaker: M.call().returns(M.remotable('TimerWaker')),
-      }),
-      public: M.interface('public', {
-        getCollateralManager: M.call(BrandShape).returns(M.remotable()),
-        getDebtIssuer: M.call().returns(IssuerShape),
-        getSubscription: M.call({ collateralBrand: BrandShape }).returns(
-          SubscriberShape,
-        ),
-        getElectorateSubscription: M.call().returns(SubscriberShape),
-        getGovernedParams: M.call({ collateralBrand: BrandShape }).returns(
-          M.record(),
-        ),
-        getInvitationAmount: M.call(M.string()).returns(AmountShape),
-        getPublicTopics: M.call().returns(TopicsRecordShape),
-      }),
-      helper: M.interface('helper', {
-        resetWakeupsForNextAuction: M.call().returns(M.promise()),
-        start: M.call().returns(M.promise()),
-      }),
-    },
-    initState,
-    {
-      creator: {
-        getParamMgrRetriever: () =>
-          Far('paramManagerRetriever', {
-            /** @param {VaultFactoryParamPath} paramPath */
-            get: (
-              paramPath = { key: /** @type {const} */ 'governedParams' },
-            ) => {
-              if (paramPath.key === 'governedParams') {
-                return directorParamManager;
-              } else if (paramPath.key.collateralBrand) {
-                return vaultParamManagers.get(paramPath.key.collateralBrand);
-              } else {
-                assert.fail('Unsupported paramPath');
-              }
-            },
-          }),
-        /**
-         * @param {string} name
-         */
-        getInvitation(name) {
-          return directorParamManager.getInternalParamValue(name);
-        },
-        getLimitedCreatorFacet() {
-          return this.facets.machine;
-        },
-        /** @returns {ERef<GovernedApis>} */
-        getGovernedApis() {
-          // @ts-expect-error cast
-          return Far('governedAPIs', {});
-        },
-        getGovernedApiNames() {
-          return harden([]);
-        },
-        setOfferFilter: strings => zcf.setOfferFilter(strings),
-      },
-      machine: {
-        // TODO move this under governance #3924
-        /**
-         * @param {Issuer<'nat'>} collateralIssuer
-         * @param {Keyword} collateralKeyword
-         * @param {VaultManagerParamValues} initialParamValues
-         */
-        async addVaultType(
-          collateralIssuer,
-          collateralKeyword,
-          initialParamValues,
-        ) {
-          trace('addVaultType', collateralKeyword, initialParamValues);
-          mustMatch(collateralIssuer, M.remotable(), 'collateralIssuer');
-          assertKeywordName(collateralKeyword);
-          mustMatch(
-            initialParamValues,
-            vaultParamPattern,
-            'initialParamValues',
-          );
-          await zcf.saveIssuer(collateralIssuer, collateralKeyword);
-          const collateralBrand = zcf.getBrandForIssuer(collateralIssuer);
-          // We create only one vault per collateralType.
-          !collateralManagers.has(collateralBrand) ||
-            Fail`Collateral brand ${q(collateralBrand)} has already been added`;
-
-          // zero-based index of the manager being made
-          const managerIndex = vaultManagers.length();
-          const managerId = `manager${managerIndex}`;
-          const managerStorageNode = await E(managersNode).makeChildNode(
-            managerId,
-          );
-
-          vaultParamManagers.addParamManager(
-            collateralBrand,
-            managerStorageNode,
-            initialParamValues,
-          );
-
-          const startTimeStamp = await E(timer).getCurrentTimestamp();
-
-          const collateralUnit = await unitAmount(collateralBrand);
-
-          const kit = await makeVaultManagerKit({
-            debtMint,
-            collateralBrand,
-            collateralUnit,
-            descriptionScope: managerId,
-            startTimeStamp,
-            storageNode: managerStorageNode,
-          });
-          vaultManagers.add(kit);
-          vaultManagers.length() - 1 === managerIndex ||
-            Fail`mismatch VaultManagerKit count`;
-          const { self: vm } = kit;
-          vm || Fail`no vault`;
-          collateralManagers.init(collateralBrand, managerIndex);
-          void writeMetrics();
-          return vm;
-        },
-        makeCollectFeesInvitation() {
-          return makeCollectFeesInvitation(
-            zcf,
-            rewardPoolSeat,
-            debtMint.getIssuerRecord().brand,
-            'Minted',
-          );
-        },
-        // XXX accessors for tests
-        getRewardAllocation() {
-          return rewardPoolSeat.getCurrentAllocation();
-        },
-
-        makeLiquidationWaker() {
-          return makeWaker('liquidationWaker', _timestamp => {
-            allManagersDo(vm => vm.liquidateVaults(auctioneer));
-          });
-        },
-        makeReschedulerWaker() {
-          const { facets } = this;
-          return makeWaker('reschedulerWaker', () => {
-            void facets.helper.resetWakeupsForNextAuction();
-          });
-        },
-        makePriceLockWaker() {
-          return makeWaker('priceLockWaker', () => {
-            allManagersDo(vm => vm.lockOraclePrices());
-          });
-        },
-      },
-      public: {
-        /**
-         * @param {Brand} brandIn
-         */
-        getCollateralManager(brandIn) {
-          collateralManagers.has(brandIn) ||
-            Fail`Not a supported collateral type ${brandIn}`;
-          /** @type {VaultManager} */
-          return managerForCollateral(brandIn).getPublicFacet();
-        },
-        getDebtIssuer() {
-          return debtMint.getIssuerRecord().issuer;
-        },
-        /**
-         * subscription for the paramManager for a particular vaultManager
-         *
-         * @param {{ collateralBrand: Brand }} selector
-         */
-        getSubscription({ collateralBrand }) {
-          return vaultParamManagers.get(collateralBrand).getSubscription();
-        },
-        getPublicTopics() {
-          return topics;
-        },
-        /**
-         * subscription for the paramManager for the vaultFactory's electorate
-         */
-        getElectorateSubscription() {
-          return directorParamManager.getSubscription();
-        },
-        /**
-         * @param {{ collateralBrand: Brand }} selector
-         */
-        getGovernedParams({ collateralBrand }) {
-          // TODO use named getters of TypedParamManager
-          return vaultParamManagers.get(collateralBrand).getParams();
-        },
-        /**
-         * @param {string} name
-         */
-        getInvitationAmount(name) {
-          return directorParamManager.getInvitationAmount(name);
-        },
-      },
-      helper: {
-        resetWakeupsForNextAuction() {
-          const { facets } = this;
-
-          const priceLockWaker = facets.machine.makePriceLockWaker();
-          const liquidationWaker = facets.machine.makeLiquidationWaker();
-          const rescheduleWaker = facets.machine.makeReschedulerWaker();
-          return setWakeupsForNextAuction(
-            auctioneer,
-            timer,
-            priceLockWaker,
-            liquidationWaker,
-            rescheduleWaker,
-          );
-        },
-        /**
-         * Start non-durable processes (or restart if needed after vat restart)
-         */
-        async start() {
-          const { helper, machine } = this.facets;
-
-          await helper.resetWakeupsForNextAuction();
-          updateShortfallReporter().catch(err =>
-            console.error(
-              '🛠️ updateShortfallReporter failed during start(); repair by updating governance',
-              err,
-            ),
-          );
-          // independent of the other one which can be canceled
-          const rescheduleWaker = machine.makeReschedulerWaker();
-          void watchForGovernanceChange(auctioneer, timer, rescheduleWaker);
-        },
-      },
-    },
-  );
-  return makeVaultDirector;
-};
-harden(prepareVaultDirector);
-
-/**
- * Prepare the VaultDirector kind, get or make the singleton
- *
- * @type {(...pvdArgs: Parameters<typeof prepareVaultDirector>) => ReturnType<ReturnType<typeof prepareVaultDirector>>}
- */
-export const provideDirector = (...args) => {
-  const makeVaultDirector = prepareVaultDirector(...args);
-
-  const [baggage] = args;
-
-  return provide(baggage, 'director', makeVaultDirector);
-};
-harden(provideDirector);
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultFactory.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultFactory.js
deleted file mode 100644
index b2a187e931c..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultFactory.js
+++ /dev/null
@@ -1,149 +0,0 @@
-// @jessie-check
-
-import '@agoric/governance/exported.js';
-import '@agoric/zoe/exported.js';
-import '@agoric/zoe/src/contracts/exported.js';
-
-// The vaultFactory owns a number of VaultManagers and a mint for Minted.
-//
-// addVaultType is a closely held method that adds a brand new collateral type.
-// It specifies the initial exchange rate for that type. It depends on a
-// separately specified mechanism to liquidate vaults that are
-// in arrears.
-
-// This contract wants to be managed by a contractGovernor, but it isn't
-// compatible with contractGovernor, since it has a separate paramManager for
-// each VaultManager. This requires it to manually replicate the API of
-// contractHelper to satisfy contractGovernor. It needs to return a creatorFacet
-// with { getParamMgrRetriever, getInvitation, getLimitedCreatorFacet }.
-
-import { CONTRACT_ELECTORATE } from '@agoric/governance';
-import { makeParamManagerFromTerms } from '@agoric/governance/src/contractGovernance/typedParamManager.js';
-import { validateElectorate } from '@agoric/governance/src/contractHelper.js';
-import { makeTracer, StorageNodeShape } from '@agoric/internal';
-import { makeStoredSubscription, makeSubscriptionKit } from '@agoric/notifier';
-import { M } from '@agoric/store';
-import { provideAll } from '@agoric/zoe/src/contractSupport/durability.js';
-import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport/recorder.js';
-import { E } from '@endo/eventual-send';
-import { FeeMintAccessShape } from '@agoric/zoe/src/typeGuards.js';
-import { InvitationShape } from '@agoric/inter-protocol/src/auction/params.js';
-import { SHORTFALL_INVITATION_KEY, vaultDirectorParamTypes } from './params.js';
-import { provideDirector } from './vaultDirector.js';
-
-const trace = makeTracer('VF', true);
-
-/**
- * @typedef {ZCF<GovernanceTerms<import('./params').VaultDirectorParams> & {
- *   auctioneerPublicFacet: import('@agoric/inter-protocol/src/auction/auctioneer.js').AuctioneerPublicFacet,
- *   priceAuthority: ERef<PriceAuthority>,
- *   reservePublicFacet: AssetReservePublicFacet,
- *   timerService: import('@agoric/time/src/types').TimerService,
- * }>} VaultFactoryZCF
- */
-
-export const privateArgsShape = M.splitRecord(
-  harden({
-    marshaller: M.remotable('Marshaller'),
-    storageNode: StorageNodeShape,
-  }),
-  harden({
-    // only necessary on first invocation, not subsequent
-    feeMintAccess: FeeMintAccessShape,
-    initialPoserInvitation: InvitationShape,
-    initialShortfallInvitation: InvitationShape,
-  }),
-);
-harden(privateArgsShape);
-
-/**
- * @param {VaultFactoryZCF} zcf
- * @param {{
- *   feeMintAccess: FeeMintAccess,
- *   initialPoserInvitation: Invitation,
- *   initialShortfallInvitation: Invitation,
- *   storageNode: ERef<StorageNode>,
- *   marshaller: ERef<Marshaller>,
- * }} privateArgs
- * @param {import('@agoric/ertp').Baggage} baggage
- */
-export const prepare = async (zcf, privateArgs, baggage) => {
-  trace('prepare start', privateArgs, [...baggage.keys()]);
-  const {
-    initialPoserInvitation,
-    initialShortfallInvitation,
-    marshaller,
-    storageNode,
-  } = privateArgs;
-
-  trace('awaiting debtMint');
-  const { debtMint } = await provideAll(baggage, {
-    debtMint: () => zcf.registerFeeMint('Minted', privateArgs.feeMintAccess),
-  });
-
-  zcf.setTestJig(() => ({
-    mintedIssuerRecord: debtMint.getIssuerRecord(),
-  }));
-
-  const { timerService, auctioneerPublicFacet } = zcf.getTerms();
-
-  const { makeRecorderKit, makeERecorderKit } = prepareRecorderKitMakers(
-    baggage,
-    marshaller,
-  );
-
-  trace('making non-durable publishers');
-  // XXX non-durable, will sever upon vat restart
-  const governanceSubscriptionKit = makeSubscriptionKit();
-  const governanceNode = E(storageNode).makeChildNode('governance');
-  const governanceSubscriber = makeStoredSubscription(
-    governanceSubscriptionKit.subscription,
-    governanceNode,
-    marshaller,
-  );
-  /** a powerful object; can modify the invitation */
-  trace('awaiting makeParamManagerFromTerms');
-  const vaultDirectorParamManager = await makeParamManagerFromTerms(
-    {
-      publisher: governanceSubscriptionKit.publication,
-      subscriber: governanceSubscriber,
-    },
-    zcf,
-    {
-      [CONTRACT_ELECTORATE]: initialPoserInvitation,
-      [SHORTFALL_INVITATION_KEY]: initialShortfallInvitation,
-    },
-    vaultDirectorParamTypes,
-  );
-
-  const director = provideDirector(
-    baggage,
-    zcf,
-    vaultDirectorParamManager,
-    debtMint,
-    timerService,
-    auctioneerPublicFacet,
-    storageNode,
-    // XXX remove Recorder makers; remove once we excise deprecated kits for governance
-    marshaller,
-    makeRecorderKit,
-    makeERecorderKit,
-  );
-
-  // cannot await because it would make remote calls during vat restart
-  director.helper.start().catch(err => {
-    console.error('💀 vaultDirector failed to start:', err);
-    zcf.shutdownWithFailure(err);
-  });
-
-  // validate async to wait for params to be finished
-  // UNTIL https://github.com/Agoric/agoric-sdk/issues/4343
-  void validateElectorate(zcf, vaultDirectorParamManager);
-
-  return harden({
-    creatorFacet: director.creator,
-    publicFacet: director.public,
-  });
-};
-
-/** @typedef {ContractOf<typeof prepare>} VaultFactoryContract */
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultHolder.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultHolder.js
deleted file mode 100644
index db7bbaa5fa8..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultHolder.js
+++ /dev/null
@@ -1,129 +0,0 @@
-/**
- * @file Use-object for the owner of a vault
- */
-import { AmountShape } from '@agoric/ertp';
-import { M, prepareExoClassKit } from '@agoric/vat-data';
-import { TopicsRecordShape } from '@agoric/zoe/src/contractSupport/index.js';
-import { UnguardedHelperI } from '@agoric/inter-protocol/src/typeGuards.js';
-
-const { Fail } = assert;
-
-/**
- * @typedef {{
- * topicKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<VaultNotification>,
- * vault: Vault | null,
- * }} State
- */
-
-const HolderI = M.interface('holder', {
-  getCollateralAmount: M.call().returns(AmountShape),
-  getCurrentDebt: M.call().returns(AmountShape),
-  getNormalizedDebt: M.call().returns(AmountShape),
-  getPublicTopics: M.call().returns(TopicsRecordShape),
-  makeAdjustBalancesInvitation: M.call().returns(M.promise()),
-  makeCloseInvitation: M.call().returns(M.promise()),
-  makeTransferInvitation: M.call().returns(M.promise()),
-});
-
-/** @type {{ [name: string]: [ description: string, valueShape: Pattern ] }} */
-const PUBLIC_TOPICS = {
-  vault: ['Vault holder status', M.any()],
-};
-
-/**
- * @param {import('@agoric/ertp').Baggage} baggage
- * @param {import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit} makeRecorderKit
- */
-export const prepareVaultHolder = (baggage, makeRecorderKit) => {
-  const makeVaultHolderKit = prepareExoClassKit(
-    baggage,
-    'Vault Holder',
-    {
-      helper: UnguardedHelperI,
-      holder: HolderI,
-      invitationMakers: M.interface('invitationMakers', {
-        AdjustBalances: M.call().returns(M.promise()),
-        CloseVault: M.call().returns(M.promise()),
-        TransferVault: M.call().returns(M.promise()),
-      }),
-    },
-    /**
-     *
-     * @param {Vault} vault
-     * @param {StorageNode} storageNode
-     * @returns {State}
-     */
-    (vault, storageNode) => {
-      // must be the fully synchronous maker because the kit is held in durable state
-      const topicKit = makeRecorderKit(storageNode, PUBLIC_TOPICS.vault[1]);
-
-      return { topicKit, vault };
-    },
-    {
-      helper: {
-        /**
-         * @throws if this holder no longer owns the vault
-         */
-        owned() {
-          const { vault } = this.state;
-          if (!vault) {
-            throw Fail`Using vault holder after transfer`;
-          }
-          return vault;
-        },
-        getUpdater() {
-          return this.state.topicKit.recorder;
-        },
-      },
-      invitationMakers: {
-        AdjustBalances() {
-          return this.facets.holder.makeAdjustBalancesInvitation();
-        },
-        CloseVault() {
-          return this.facets.holder.makeCloseInvitation();
-        },
-        TransferVault() {
-          return this.facets.holder.makeTransferInvitation();
-        },
-      },
-      holder: {
-        getPublicTopics() {
-          const { topicKit } = this.state;
-          return harden({
-            vault: {
-              description: PUBLIC_TOPICS.vault[0],
-              subscriber: topicKit.subscriber,
-              storagePath: topicKit.recorder.getStoragePath(),
-            },
-          });
-        },
-        makeAdjustBalancesInvitation() {
-          return this.facets.helper.owned().makeAdjustBalancesInvitation();
-        },
-        makeCloseInvitation() {
-          return this.facets.helper.owned().makeCloseInvitation();
-        },
-        /**
-         * Starting a transfer revokes the vault holder. The associated updater will
-         * get a special notification that the vault is being transferred.
-         */
-        makeTransferInvitation() {
-          const vault = this.facets.helper.owned();
-          this.state.vault = null;
-          return vault.makeTransferInvitation();
-        },
-        // for status/debugging
-        getCollateralAmount() {
-          return this.facets.helper.owned().getCollateralAmount();
-        },
-        getCurrentDebt() {
-          return this.facets.helper.owned().getCurrentDebt();
-        },
-        getNormalizedDebt() {
-          return this.facets.helper.owned().getNormalizedDebt();
-        },
-      },
-    },
-  );
-  return makeVaultHolderKit;
-};
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultKit.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultKit.js
deleted file mode 100644
index 354ac3bf5d5..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultKit.js
+++ /dev/null
@@ -1,46 +0,0 @@
-// @jessie-check
-
-import '@agoric/zoe/exported.js';
-
-import { makeTracer } from '@agoric/internal';
-import { prepareVaultHolder } from './vaultHolder.js';
-
-const trace = makeTracer('VK', true);
-
-/**
- * Wrap the VaultHolder duration object in a record suitable for the result of an invitation.
- *
- * @param {import('@agoric/ertp').Baggage} baggage
- * @param {import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit} makeRecorderKit
- */
-export const prepareVaultKit = (baggage, makeRecorderKit) => {
-  trace('prepareVaultKit', [...baggage.keys()]);
-
-  const makeVaultHolder = prepareVaultHolder(baggage, makeRecorderKit);
-  /**
-   * Create a kit of utilities for use of the vault.
-   *
-   * @param {Vault} vault
-   * @param {StorageNode} storageNode
-   */
-  const makeVaultKit = (vault, storageNode) => {
-    trace('prepareVaultKit makeVaultKit');
-    const { holder, helper, invitationMakers } = makeVaultHolder(
-      vault,
-      storageNode,
-    );
-    const holderTopics = holder.getPublicTopics();
-    const vaultKit = harden({
-      publicSubscribers: {
-        vault: holderTopics.vault,
-      },
-      invitationMakers,
-      vault: holder,
-      vaultUpdater: helper.getUpdater(),
-    });
-    return vaultKit;
-  };
-  return makeVaultKit;
-};
-
-/** @typedef {(ReturnType<ReturnType<typeof prepareVaultKit>>)} VaultKit */
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultManager.js b/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultManager.js
deleted file mode 100644
index 015fe9911c6..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaultFactory/vaultManager.js
+++ /dev/null
@@ -1,1232 +0,0 @@
-/* eslint-disable consistent-return */
-/**
- * @file Vault Manager object manages vault-based debts for a collateral type.
- *
- * The responsibilities include:
- * - opening a new vault backed by the collateral
- * - publishing metrics on the vault economy for that collateral
- * - charging interest on all active vaults
- * - liquidating active vaults that have exceeded the debt ratio
- *
- * Once a vault is settled (liquidated or closed) it can still be used, traded,
- * etc. but is no longer the concern of the manager. It can't be liquidated,
- * have interest charged, or be counted in the metrics.
- *
- * Undercollateralized vaults can have their assets sent to the auctioneer to be
- * liquidated. If the auction is unsuccessful, the liquidation may be reverted.
- */
-import '@agoric/zoe/exported.js';
-
-import {
-  AmountMath,
-  AmountShape,
-  BrandShape,
-  NotifierShape,
-  RatioShape,
-} from '@agoric/ertp';
-import { makeTracer } from '@agoric/internal';
-import { makeStoredNotifier, observeNotifier } from '@agoric/notifier';
-import { appendToStoredArray } from '@agoric/store/src/stores/store-utils.js';
-import {
-  M,
-  makeScalarBigMapStore,
-  makeScalarBigSetStore,
-  prepareExoClassKit,
-  provide,
-} from '@agoric/vat-data';
-import { TransferPartShape } from '@agoric/zoe/src/contractSupport/atomicTransfer.js';
-import {
-  atomicRearrange,
-  ceilMultiplyBy,
-  floorDivideBy,
-  getAmountIn,
-  getAmountOut,
-  makeEphemeraProvider,
-  makeRatio,
-  makeRecorderTopic,
-  offerTo,
-  SubscriberShape,
-  TopicsRecordShape,
-} from '@agoric/zoe/src/contractSupport/index.js';
-import { PriceQuoteShape, SeatShape } from '@agoric/zoe/src/typeGuards.js';
-import { E } from '@endo/eventual-send';
-import { AuctionPFShape } from '@agoric/inter-protocol/src/auction/auctioneer.js';
-import {
-  checkDebtLimit,
-  makeNatAmountShape,
-  quoteAsRatio,
-} from '@agoric/inter-protocol/src/contractSupport.js';
-import { chargeInterest } from '@agoric/inter-protocol/src/interest.js';
-import { getLiquidatableVaults } from './liquidation.js';
-import { calculateMinimumCollateralization, minimumPrice } from './math.js';
-import { makePrioritizedVaults } from './prioritizedVaults.js';
-import { Phase, prepareVault } from './vault.js';
-import { calculateDistributionPlan } from './proceeds.js';
-
-const { details: X, Fail, quote: q } = assert;
-
-const trace = makeTracer('VM');
-
-/** @typedef {import('./storeUtils.js').NormalizedDebt} NormalizedDebt */
-/** @typedef {import('@agoric/time/src/types').RelativeTime} RelativeTime */
-
-// Metrics naming scheme: nouns are present values; past-participles are accumulative.
-/**
- * @typedef {object} MetricsNotification
- *
- * @property {Ratio | null} lockedQuote      priceQuote that will be used for liquidation.
- *                                   Non-null from priceLock time until liquidation has taken place.
- * @property {number}         numActiveVaults          present count of vaults
- * @property {number}         numLiquidatingVaults  present count of liquidating vaults
- * @property {Amount<'nat'>}  totalCollateral    present sum of collateral across all vaults
- * @property {Amount<'nat'>}  totalDebt          present sum of debt across all vaults
- * @property {Amount<'nat'>}  retainedCollateral collateral held as a result of not returning excess refunds
- *                                                to owners of vaults liquidated with shortfalls
- * @property {Amount<'nat'>}  liquidatingCollateral  present sum of collateral in vaults sent for liquidation
- * @property {Amount<'nat'>}  liquidatingDebt        present sum of debt in vaults sent for liquidation
- *
- * @property {Amount<'nat'>}  totalCollateralSold       running sum of collateral sold in liquidation
- * @property {Amount<'nat'>}  totalOverageReceived      running sum of overages, central received greater than debt
- * @property {Amount<'nat'>}  totalProceedsReceived     running sum of minted received from liquidation
- * @property {Amount<'nat'>}  totalShortfallReceived    running sum of shortfalls, minted received less than debt
- * @property {number}         numLiquidationsCompleted  running count of liquidated vaults
- * @property {number}         numLiquidationsAborted    running count of vault liquidations that were reverted.
- */
-
-/**
- * @typedef {{
- *  compoundedInterest: Ratio,
- *  interestRate: Ratio,
- *  latestInterestUpdate: Timestamp,
- * }} AssetState
- *
- * @typedef {{
- *  getChargingPeriod: () => RelativeTime,
- *  getRecordingPeriod: () => RelativeTime,
- *  getDebtLimit: () => Amount<'nat'>,
- *  getInterestRate: () => Ratio,
- *  getLiquidationPadding: () => Ratio,
- *  getLiquidationMargin: () => Ratio,
- *  getLiquidationPenalty: () => Ratio,
- *  getMintFee: () => Ratio,
- *  getMinInitialDebt: () => Amount<'nat'>,
- * }} GovernedParamGetters
- */
-
-/**
- * @typedef {Readonly<{
- *   debtMint: ZCFMint<'nat'>,
- *   collateralBrand: Brand<'nat'>,
- *   collateralUnit: Amount<'nat'>,
- *   descriptionScope: string,
- *   startTimeStamp: Timestamp,
- *   storageNode: StorageNode,
- * }>} HeldParams
- */
-
-/**
- * @typedef {{
- *   assetTopicKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<AssetState>,
- *   debtBrand: Brand<'nat'>,
- *   liquidatingVaults: SetStore<Vault>,
- *   metricsTopicKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<MetricsNotification>,
- *   poolIncrementSeat: ZCFSeat,
- *   retainedCollateralSeat: ZCFSeat,
- *   unsettledVaults: MapStore<string, Vault>,
- * }} ImmutableState
- */
-
-/**
- * @typedef {{
- *   compoundedInterest: Ratio,
- *   latestInterestUpdate: Timestamp,
- *   numLiquidationsCompleted: number,
- *   numLiquidationsAborted: number,
- *   totalCollateral: Amount<'nat'>,
- *   totalCollateralSold: Amount<'nat'>,
- *   totalDebt: Amount<'nat'>,
- *   liquidatingCollateral: Amount<'nat'>,
- *   liquidatingDebt: Amount<'nat'>,
- *   totalOverageReceived: Amount<'nat'>,
- *   totalProceedsReceived: Amount<'nat'>,
- *   totalShortfallReceived: Amount<'nat'>,
- *   vaultCounter: number,
- *   lockedQuote: PriceQuote | undefined,
- * }} MutableState
- */
-
-/**
- * @type {(brand: Brand) => {
- * prioritizedVaults: ReturnType<typeof makePrioritizedVaults>,
- * storedQuotesNotifier: import('@agoric/notifier').StoredNotifier<PriceQuote>,
- * storedCollateralQuote: PriceQuote,
- * }}
- */
-// any b/c will be filled after start()
-const collateralEphemera = makeEphemeraProvider(() => /** @type {any} */ ({}));
-
-/**
- * @param {import('@agoric/ertp').Baggage} baggage
- * @param {{
- *   zcf: import('./vaultFactory.js').VaultFactoryZCF,
- *   marshaller: ERef<Marshaller>,
- *   makeRecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit,
- *   makeERecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').MakeERecorderKit,
- *   factoryPowers: import('./vaultDirector.js').FactoryPowersFacet,
- * }} powers
- */
-export const prepareVaultManagerKit = (
-  baggage,
-  { zcf, marshaller, makeRecorderKit, factoryPowers },
-) => {
-  const { priceAuthority, timerService, reservePublicFacet } = zcf.getTerms();
-
-  const makeVault = prepareVault(baggage, makeRecorderKit, zcf);
-
-  /**
-   * @param {HeldParams & { metricsStorageNode: StorageNode }} params
-   * @returns {HeldParams & ImmutableState & MutableState}
-   */
-  const initState = params => {
-    const {
-      debtMint,
-      collateralBrand,
-      metricsStorageNode,
-      startTimeStamp,
-      storageNode,
-    } = params;
-    const debtBrand = debtMint.getIssuerRecord().brand;
-
-    /** @type {ImmutableState} */
-    const immutable = {
-      debtBrand,
-      poolIncrementSeat: zcf.makeEmptySeatKit().zcfSeat,
-
-      /**
-       * Vaults that have been sent for liquidation. When we get proceeds (or lack
-       * thereof) back from the liquidator, we will allocate them among the vaults.
-       *
-       * @type {SetStore<Vault>}
-       */
-      liquidatingVaults: makeScalarBigSetStore('liquidatingVaults', {
-        durable: true,
-      }),
-
-      assetTopicKit: makeRecorderKit(storageNode),
-
-      metricsTopicKit: makeRecorderKit(metricsStorageNode),
-
-      // TODO(#7074) not used while liquidation is disabled. Reinstate with #7074
-      retainedCollateralSeat: zcf.makeEmptySeatKit().zcfSeat,
-
-      unsettledVaults: makeScalarBigMapStore('orderedVaultStore', {
-        durable: true,
-      }),
-    };
-
-    const zeroCollateral = AmountMath.makeEmpty(collateralBrand, 'nat');
-    const zeroDebt = AmountMath.makeEmpty(debtBrand, 'nat');
-
-    return harden({
-      ...params,
-      ...immutable,
-      compoundedInterest: makeRatio(100n, debtBrand), // starts at 1.0, no interest
-      latestInterestUpdate: startTimeStamp,
-      numLiquidationsCompleted: 0,
-      numLiquidationsAborted: 0,
-      totalCollateral: zeroCollateral,
-      totalCollateralSold: zeroCollateral,
-      totalDebt: zeroDebt,
-      liquidatingCollateral: zeroCollateral,
-      liquidatingDebt: zeroDebt,
-      totalOverageReceived: zeroDebt,
-      totalProceedsReceived: zeroDebt,
-      totalShortfallReceived: zeroDebt,
-      vaultCounter: 0,
-      lockedQuote: undefined,
-    });
-  };
-
-  const makeVaultManagerKitInternal = prepareExoClassKit(
-    baggage,
-    'VaultManagerKit',
-    {
-      collateral: M.interface('collateral', {
-        makeVaultInvitation: M.call().returns(M.promise()),
-        getPublicTopics: M.call().returns(TopicsRecordShape),
-        getQuotes: M.call().returns(NotifierShape),
-        getCompoundedInterest: M.call().returns(RatioShape),
-      }),
-      helper: M.interface(
-        'helper',
-        // not exposed so sloppy okay
-        {},
-        { sloppy: true },
-      ),
-      manager: M.interface('manager', {
-        getGovernedParams: M.call().returns(M.remotable('governedParams')),
-        maxDebtFor: M.call(AmountShape).returns(AmountShape),
-        mintAndTransfer: M.call(
-          SeatShape,
-          AmountShape,
-          AmountShape,
-          M.arrayOf(TransferPartShape),
-        ).returns(),
-        burn: M.call(AmountShape, SeatShape).returns(),
-        getAssetSubscriber: M.call().returns(SubscriberShape),
-        getCollateralBrand: M.call().returns(BrandShape),
-        getDebtBrand: M.call().returns(BrandShape),
-        getCompoundedInterest: M.call().returns(RatioShape),
-        scopeDescription: M.call(M.string()).returns(M.string()),
-        handleBalanceChange: M.call(
-          AmountShape,
-          AmountShape,
-          M.string(),
-          M.string(),
-          M.remotable('vault'),
-        ).returns(),
-      }),
-      self: M.interface('self', {
-        getGovernedParams: M.call().returns(M.remotable('governedParams')),
-        makeVaultKit: M.call(SeatShape).returns(M.promise()),
-        getCollateralQuote: M.call().returns(PriceQuoteShape),
-        getPublicFacet: M.call().returns(M.remotable('publicFacet')),
-        lockOraclePrices: M.call().returns(PriceQuoteShape),
-        liquidateVaults: M.call(AuctionPFShape).returns(M.promise()),
-      }),
-    },
-    initState,
-    {
-      collateral: {
-        makeVaultInvitation() {
-          const { facets } = this;
-          const { collateralBrand, debtBrand } = this.state;
-          return zcf.makeInvitation(
-            seat => this.facets.self.makeVaultKit(seat),
-            facets.manager.scopeDescription('MakeVault'),
-            undefined,
-            M.splitRecord({
-              give: {
-                Collateral: makeNatAmountShape(collateralBrand),
-              },
-              want: {
-                Minted: makeNatAmountShape(debtBrand),
-              },
-            }),
-          );
-        },
-        getQuotes() {
-          const ephemera = collateralEphemera(this.state.collateralBrand);
-          return ephemera.storedQuotesNotifier;
-        },
-        getCompoundedInterest() {
-          return this.state.compoundedInterest;
-        },
-        getPublicTopics() {
-          const { assetTopicKit, metricsTopicKit } = this.state;
-          return harden({
-            asset: makeRecorderTopic(
-              'State of the assets managed',
-              assetTopicKit,
-            ),
-            metrics: makeRecorderTopic(
-              'Vault Factory metrics',
-              metricsTopicKit,
-            ),
-          });
-        },
-      },
-
-      // Some of these could go in closures but are kept on a facet anticipating future durability options.
-      helper: {
-        /**
-         * Start non-durable processes (or restart if needed after vat restart)
-         */
-        start() {
-          const { state, facets } = this;
-          trace(state.collateralBrand, 'helper.start()', state.vaultCounter);
-          const {
-            collateralBrand,
-            collateralUnit,
-            debtBrand,
-            storageNode,
-            unsettledVaults,
-          } = state;
-
-          const ephemera = collateralEphemera(collateralBrand);
-          ephemera.prioritizedVaults = makePrioritizedVaults(unsettledVaults);
-
-          trace('helper.start() making periodNotifier');
-          const periodNotifier = E(timerService).makeNotifier(
-            0n,
-            factoryPowers
-              .getGovernedParams(collateralBrand)
-              .getChargingPeriod(),
-          );
-
-          trace('helper.start() starting observe periodNotifier');
-          void observeNotifier(periodNotifier, {
-            updateState: updateTime =>
-              facets.helper
-                .chargeAllVaults(updateTime)
-                .catch(e =>
-                  console.error('🚨 vaultManager failed to charge interest', e),
-                ),
-            fail: reason => {
-              zcf.shutdownWithFailure(
-                assert.error(X`Unable to continue without a timer: ${reason}`),
-              );
-            },
-            finish: done => {
-              zcf.shutdownWithFailure(
-                assert.error(X`Unable to continue without a timer: ${done}`),
-              );
-            },
-          });
-
-          trace('helper.start() making quoteNotifier from', priceAuthority);
-          const quoteNotifier = E(priceAuthority).makeQuoteNotifier(
-            collateralUnit,
-            debtBrand,
-          );
-          ephemera.storedQuotesNotifier = makeStoredNotifier(
-            quoteNotifier,
-            E(storageNode).makeChildNode('quotes'),
-            marshaller,
-          );
-          trace('helper.start() awaiting observe storedQuotesNotifier');
-          // NB: upon restart, there may not be a price for a while. If manager
-          // operations are permitted, ones the depend on price information will
-          // throw. See https://github.com/Agoric/agoric-sdk/issues/4317
-          void observeNotifier(quoteNotifier, {
-            updateState(value) {
-              trace('vaultManager got new collateral quote', value);
-              ephemera.storedCollateralQuote = value;
-            },
-            fail(reason) {
-              console.error('quoteNotifier failed to iterate', reason);
-            },
-          });
-          trace('helper.start() done');
-        },
-        /**
-         * @param {Timestamp} updateTime
-         */
-        async chargeAllVaults(updateTime) {
-          const { state, facets } = this;
-          const { collateralBrand, debtMint, poolIncrementSeat } = state;
-          trace(collateralBrand, 'chargeAllVaults', {
-            updateTime,
-          });
-
-          const interestRate = factoryPowers
-            .getGovernedParams(collateralBrand)
-            .getInterestRate();
-
-          // Update state with the results of charging interest
-
-          const changes = chargeInterest(
-            {
-              mint: debtMint,
-              mintAndTransferWithFee: factoryPowers.mintAndTransfer,
-              poolIncrementSeat,
-              seatAllocationKeyword: 'Minted',
-            },
-            {
-              interestRate,
-              chargingPeriod: factoryPowers
-                .getGovernedParams(collateralBrand)
-                .getChargingPeriod(),
-              recordingPeriod: factoryPowers
-                .getGovernedParams(collateralBrand)
-                .getRecordingPeriod(),
-            },
-            {
-              latestInterestUpdate: state.latestInterestUpdate,
-              compoundedInterest: state.compoundedInterest,
-              totalDebt: state.totalDebt,
-            },
-            updateTime,
-          );
-
-          state.compoundedInterest = changes.compoundedInterest;
-          state.latestInterestUpdate = changes.latestInterestUpdate;
-          state.totalDebt = changes.totalDebt;
-
-          return facets.helper.assetNotify();
-        },
-        assetNotify() {
-          const { state } = this;
-          const { collateralBrand, assetTopicKit } = state;
-          const interestRate = factoryPowers
-            .getGovernedParams(collateralBrand)
-            .getInterestRate();
-          /** @type {AssetState} */
-          const payload = harden({
-            compoundedInterest: state.compoundedInterest,
-            interestRate,
-            latestInterestUpdate: state.latestInterestUpdate,
-          });
-          return assetTopicKit.recorder.write(payload);
-        },
-        burnToCoverDebt(debt, proceeds, seat) {
-          const { state } = this;
-
-          if (AmountMath.isGTE(proceeds, debt)) {
-            factoryPowers.burnDebt(debt, seat);
-            state.totalDebt = AmountMath.subtract(state.totalDebt, debt);
-          } else {
-            factoryPowers.burnDebt(proceeds, seat);
-            state.totalDebt = AmountMath.subtract(state.totalDebt, proceeds);
-          }
-
-          state.totalProceedsReceived = AmountMath.add(
-            state.totalProceedsReceived,
-            proceeds,
-          );
-        },
-        sendToReserve(penalty, seat, seatKeyword = 'Collateral') {
-          const invitation =
-            E(reservePublicFacet).makeAddCollateralInvitation();
-          trace('Sending to reserve: ', penalty);
-
-          // don't wait for response
-          void E.when(invitation, invite => {
-            const proposal = { give: { Collateral: penalty } };
-            return offerTo(
-              zcf,
-              invite,
-              { [seatKeyword]: 'Collateral' },
-              proposal,
-              seat,
-            );
-          }).catch(reason => {
-            console.error('sendToReserve failed', reason);
-          });
-        },
-        markLiquidating(debt, collateral) {
-          const { state } = this;
-
-          state.liquidatingCollateral = AmountMath.add(
-            state.liquidatingCollateral,
-            collateral,
-          );
-
-          state.liquidatingDebt = AmountMath.add(state.liquidatingDebt, debt);
-        },
-        /**
-         *
-         * @param {Amount<'nat'>} debt
-         * @param {Amount<'nat'>} collateral
-         * @param {Amount<'nat'>} overage
-         * @param {Amount<'nat'>} shortfall
-         */
-        markDoneLiquidating(debt, collateral, overage, shortfall) {
-          const { state } = this;
-
-          // update liquidation state
-
-          state.liquidatingCollateral = AmountMath.subtract(
-            state.liquidatingCollateral,
-            collateral,
-          );
-          state.liquidatingDebt = AmountMath.subtract(
-            state.liquidatingDebt,
-            debt,
-          );
-
-          // record shortfall and proceeds
-
-          // cumulative values
-          state.totalOverageReceived = AmountMath.add(
-            state.totalOverageReceived,
-            overage,
-          );
-          state.totalShortfallReceived = AmountMath.add(
-            state.totalShortfallReceived,
-            shortfall,
-          );
-          state.totalDebt = AmountMath.subtract(state.totalDebt, shortfall);
-
-          E.when(
-            factoryPowers.getShortfallReporter(),
-            reporter => E(reporter).increaseLiquidationShortfall(shortfall),
-            err =>
-              console.error(
-                '🛠️ getShortfallReporter() failed during liquidation; repair by updating governance',
-                err,
-              ),
-          ).catch(err => {
-            console.error('🚨 failed to report liquidation shortfall', err);
-          });
-        },
-        writeMetrics() {
-          const { state } = this;
-          const { collateralBrand, retainedCollateralSeat, metricsTopicKit } =
-            state;
-          const { prioritizedVaults } = collateralEphemera(collateralBrand);
-
-          const retainedCollateral =
-            retainedCollateralSeat.getCurrentAllocation()?.Collateral ??
-            AmountMath.makeEmpty(collateralBrand, 'nat');
-
-          const quote = state.lockedQuote;
-          const lockedQuoteRatio = quote
-            ? quoteAsRatio(quote.quoteAmount.value[0])
-            : null;
-
-          /** @type {MetricsNotification} */
-          const payload = harden({
-            numActiveVaults: prioritizedVaults.getCount(),
-            numLiquidatingVaults: state.liquidatingVaults.getSize(),
-            totalCollateral: state.totalCollateral,
-            totalDebt: state.totalDebt,
-            retainedCollateral,
-
-            numLiquidationsCompleted: state.numLiquidationsCompleted,
-            numLiquidationsAborted: state.numLiquidationsAborted,
-            totalCollateralSold: state.totalCollateralSold,
-            liquidatingCollateral: state.liquidatingCollateral,
-            liquidatingDebt: state.liquidatingDebt,
-            totalOverageReceived: state.totalOverageReceived,
-            totalProceedsReceived: state.totalProceedsReceived,
-            totalShortfallReceived: state.totalShortfallReceived,
-            lockedQuote: lockedQuoteRatio,
-          });
-
-          return E(metricsTopicKit.recorder).write(payload);
-        },
-
-        /**
-         * This is designed to tolerate an incomplete plan, in case calculateDistributionPlan encounters
-         * an error during its calculation. We don't have a way to induce such errors in CI so we've
-         * done so manually in dev and verified this function recovers as expected.
-         *
-         * @param {AmountKeywordRecord} proceeds
-         * @param {Amount<'nat'>} totalDebt
-         * @param {Pick<PriceQuote, 'quoteAmount'>} oraclePriceAtStart
-         * @param {MapStore<Vault, { collateralAmount: Amount<'nat'>, debtAmount:  Amount<'nat'>}>} vaultData
-         * @param {Amount<'nat'>} totalCollateral
-         */
-        planProceedsDistribution(
-          proceeds,
-          totalDebt,
-          oraclePriceAtStart,
-          vaultData,
-          totalCollateral,
-        ) {
-          const { state, facets } = this;
-
-          const { Collateral: collateralProceeds } = proceeds;
-          /** @type {Amount<'nat'>} */
-          const collateralSold = AmountMath.subtract(
-            totalCollateral,
-            collateralProceeds,
-          );
-          state.totalCollateralSold = AmountMath.add(
-            state.totalCollateralSold,
-            collateralSold,
-          );
-
-          const penaltyRate = facets.self
-            .getGovernedParams()
-            .getLiquidationPenalty();
-          const bestToWorst = [...vaultData.entries()].reverse();
-
-          // unzip the entry tuples
-          const vaultsInPlan = /** @type {Vault[]} */ ([]);
-          const vaultsBalances =
-            /** @type {import('./proceeds.js').VaultBalances[]} */ ([]);
-          for (const [vault, balances] of bestToWorst) {
-            vaultsInPlan.push(vault);
-            vaultsBalances.push({
-              collateral: balances.collateralAmount,
-              // if interest accrued during sale, the current debt will be higher
-              presaleDebt: balances.debtAmount,
-              currentDebt: vault.getCurrentDebt(),
-            });
-          }
-          harden(vaultsInPlan);
-          harden(vaultsBalances);
-
-          const plan = calculateDistributionPlan({
-            proceeds,
-            totalDebt,
-            totalCollateral,
-            oraclePriceAtStart: oraclePriceAtStart.quoteAmount.value[0],
-            vaultsBalances,
-            penaltyRate,
-          });
-          return { plan, vaultsInPlan };
-        },
-
-        /**
-         * This is designed to tolerate an incomplete plan, in case calculateDistributionPlan encounters
-         * an error during its calculation. We don't have a way to induce such errors in CI so we've
-         * done so manually in dev and verified this function recovers as expected.
-         *
-         * @param {object} obj
-         * @param {import('./proceeds.js').DistributionPlan} obj.plan
-         * @param {Array<Vault>} obj.vaultsInPlan
-         * @param {ZCFSeat} obj.liqSeat
-         * @param {Amount<'nat'>} obj.totalCollateral
-         * @param {Amount<'nat'>} obj.totalDebt
-         * @returns {void}
-         */
-        distributeProceeds({
-          plan,
-          vaultsInPlan,
-          liqSeat,
-          totalCollateral,
-          totalDebt,
-        }) {
-          const { state, facets } = this;
-          // Putting all the rearrangements after the loop ensures that errors
-          // in the calculations don't result in paying back some vaults and
-          // leaving others hanging.
-          if (plan.transfersToVault.length > 0) {
-            const transfers = plan.transfersToVault.map(
-              ([vaultIndex, amounts]) =>
-                /** @type {import('@agoric/zoe/src/contractSupport/atomicTransfer.js').TransferPart} */ ([
-                  liqSeat,
-                  vaultsInPlan[vaultIndex].getVaultSeat(),
-                  amounts,
-                ]),
-            );
-            atomicRearrange(zcf, harden(transfers));
-          }
-
-          const { prioritizedVaults } = collateralEphemera(
-            totalCollateral.brand,
-          );
-          state.numLiquidationsAborted += plan.vaultsToReinstate.length;
-          for (const vaultIndex of plan.vaultsToReinstate) {
-            const vault = vaultsInPlan[vaultIndex];
-            const vaultId = vault.abortLiquidation();
-            prioritizedVaults.addVault(vaultId, vault);
-            state.liquidatingVaults.delete(vault);
-          }
-
-          if (!AmountMath.isEmpty(plan.phantomDebt)) {
-            state.totalDebt = AmountMath.subtract(
-              state.totalDebt,
-              plan.phantomDebt,
-            );
-          }
-
-          facets.helper.burnToCoverDebt(
-            plan.debtToBurn,
-            plan.mintedProceeds,
-            liqSeat,
-          );
-          if (!AmountMath.isEmpty(plan.mintedForReserve)) {
-            facets.helper.sendToReserve(
-              plan.mintedForReserve,
-              liqSeat,
-              'Minted',
-            );
-          }
-
-          // send all that's left in the seat
-          const collateralInLiqSeat = liqSeat.getCurrentAllocation().Collateral;
-          if (!AmountMath.isEmpty(collateralInLiqSeat)) {
-            facets.helper.sendToReserve(collateralInLiqSeat, liqSeat);
-          }
-          // if it didn't match what was expected, report
-          if (!AmountMath.isEqual(collateralInLiqSeat, plan.collatRemaining)) {
-            console.error(
-              `⚠️ Excess collateral remaining sent to reserve. Expected ${q(
-                plan.collatRemaining,
-              )}, sent ${q(collateralInLiqSeat)}`,
-            );
-          }
-
-          // 'totalCollateralSold' is only for this liquidation event
-          // 'state.totalCollateralSold' represents all active vaults
-          const actualCollateralSold = plan.actualCollateralSold;
-          state.totalCollateral = AmountMath.isEmpty(actualCollateralSold)
-            ? AmountMath.subtract(state.totalCollateral, totalCollateral)
-            : AmountMath.subtract(state.totalCollateral, actualCollateralSold);
-
-          facets.helper.markDoneLiquidating(
-            totalDebt,
-            totalCollateral,
-            plan.overage,
-            plan.shortfallToReserve,
-          );
-
-          // liqSeat should be empty at this point, except that funds are sent
-          // asynchronously to the reserve.
-        },
-      },
-
-      manager: {
-        getGovernedParams() {
-          const { collateralBrand } = this.state;
-          return factoryPowers.getGovernedParams(collateralBrand);
-        },
-
-        /**
-         * Look up the most recent price authority price to determine the max
-         * debt this manager config will allow for the collateral.
-         *
-         * @param {Amount<'nat'>} collateralAmount
-         */
-        maxDebtFor(collateralAmount) {
-          const { collateralBrand } = this.state;
-          const { storedCollateralQuote } = collateralEphemera(collateralBrand);
-          if (!storedCollateralQuote)
-            throw Fail`maxDebtFor called before a collateral quote was available`;
-          // use the lower price to prevent vault adjustments that put them imminently underwater
-          const collateralPrice = minimumPrice(
-            storedCollateralQuote,
-            this.state.lockedQuote,
-          );
-          const collatlVal = ceilMultiplyBy(collateralAmount, collateralPrice);
-          const minimumCollateralization = calculateMinimumCollateralization(
-            factoryPowers
-              .getGovernedParams(collateralBrand)
-              .getLiquidationMargin(),
-            factoryPowers
-              .getGovernedParams(collateralBrand)
-              .getLiquidationPadding(),
-          );
-          // floorDivide because we want the debt ceiling lower
-          return floorDivideBy(collatlVal, minimumCollateralization);
-        },
-        /** @type {MintAndTransfer} */
-        mintAndTransfer(mintReceiver, toMint, fee, transfers) {
-          const { state } = this;
-          const { collateralBrand, totalDebt } = state;
-
-          checkDebtLimit(
-            factoryPowers.getGovernedParams(collateralBrand).getDebtLimit(),
-            totalDebt,
-            toMint,
-          );
-          factoryPowers.mintAndTransfer(mintReceiver, toMint, fee, transfers);
-        },
-        /**
-         * @param {Amount<'nat'>} toBurn
-         * @param {ZCFSeat} seat
-         */
-        burn(toBurn, seat) {
-          const { state } = this;
-          const { collateralBrand } = this.state;
-
-          trace(collateralBrand, 'burn', {
-            toBurn,
-            totalDebt: state.totalDebt,
-          });
-          factoryPowers.burnDebt(toBurn, seat);
-        },
-        getAssetSubscriber() {
-          return this.state.assetTopicKit.subscriber;
-        },
-        getCollateralBrand() {
-          const { collateralBrand } = this.state;
-          return collateralBrand;
-        },
-        getDebtBrand() {
-          const { debtBrand } = this.state;
-          return debtBrand;
-        },
-        /**
-         * Prepend with an identifier of this vault manager
-         *
-         * @param {string} base
-         */
-        scopeDescription(base) {
-          const { descriptionScope } = this.state;
-          return `${descriptionScope}: ${base}`;
-        },
-        /**
-         * coefficient on existing debt to calculate new debt
-         */
-        getCompoundedInterest() {
-          return this.state.compoundedInterest;
-        },
-        /**
-         * Called by a vault when its balances change.
-         *
-         * @param {NormalizedDebt} oldDebtNormalized
-         * @param {Amount<'nat'>} oldCollateral
-         * @param {VaultId} vaultId
-         * @param {import('./vault.js').VaultPhase} vaultPhase at the end of whatever change updated balances
-         * @param {Vault} vault
-         * @returns {void}
-         */
-        handleBalanceChange(
-          oldDebtNormalized,
-          oldCollateral,
-          vaultId,
-          vaultPhase,
-          vault,
-        ) {
-          const { state, facets } = this;
-
-          // the manager holds only vaults that can accrue interest or be liquidated;
-          // i.e. vaults that have debt. The one exception is at the outset when
-          // a vault has been added to the manager but not yet accounted for.
-          const settled =
-            AmountMath.isEmpty(oldDebtNormalized) &&
-            vaultPhase !== Phase.ACTIVE;
-
-          trace('handleBalanceChange', {
-            oldDebtNormalized,
-            oldCollateral,
-            vaultId,
-            vaultPhase,
-            vault,
-            settled,
-          });
-
-          const { prioritizedVaults } = collateralEphemera(
-            state.collateralBrand,
-          );
-          if (settled) {
-            assert(
-              !prioritizedVaults.hasVaultByAttributes(
-                oldDebtNormalized,
-                oldCollateral,
-                vaultId,
-              ),
-              'Settled vaults must not be retained in storage',
-            );
-            return;
-          }
-
-          const isNew = AmountMath.isEmpty(oldDebtNormalized);
-          trace(state.collateralBrand, { isNew });
-          if (!isNew) {
-            // its position in the queue is no longer valid
-
-            const vaultInStore = prioritizedVaults.removeVaultByAttributes(
-              oldDebtNormalized,
-              oldCollateral,
-              vaultId,
-            );
-            assert(
-              vault === vaultInStore,
-              'handleBalanceChange for two different vaults',
-            );
-            trace('removed', vault, vaultId);
-          }
-
-          // replace in queue, but only if it can accrue interest or be liquidated (i.e. has debt).
-          // getCurrentDebt() would also work (0x = 0) but require more computation.
-          if (!AmountMath.isEmpty(vault.getNormalizedDebt())) {
-            prioritizedVaults.addVault(vaultId, vault);
-          }
-
-          // total += vault's delta (post — pre)
-          state.totalCollateral = AmountMath.subtract(
-            AmountMath.add(state.totalCollateral, vault.getCollateralAmount()),
-            oldCollateral,
-          );
-          state.totalDebt = AmountMath.subtract(
-            AmountMath.add(state.totalDebt, vault.getCurrentDebt()),
-            oldDebtNormalized,
-          );
-          void facets.helper.writeMetrics();
-        },
-      },
-      self: {
-        getGovernedParams() {
-          const { collateralBrand } = this.state;
-          return factoryPowers.getGovernedParams(collateralBrand);
-        },
-
-        /**
-         * @param {ZCFSeat} seat
-         */
-        async makeVaultKit(seat) {
-          const {
-            state,
-            facets: { manager },
-          } = this;
-          trace(state.collateralBrand, 'makeVaultKit');
-          const { storageNode } = this.state;
-          assert(marshaller, 'makeVaultKit missing marshaller');
-          assert(storageNode, 'makeVaultKit missing storageNode');
-          assert(zcf, 'makeVaultKit missing zcf');
-
-          const vaultId = String(state.vaultCounter);
-
-          // must be a presence to be stored in vault state
-          const vaultStorageNode = await E(
-            E(storageNode).makeChildNode(`vaults`),
-          ).makeChildNode(`vault${vaultId}`);
-
-          const { self: vault } = makeVault(manager, vaultId, vaultStorageNode);
-          trace(state.collateralBrand, 'makeVaultKit made vault', vault);
-
-          try {
-            // TODO `await` is allowed until the above ordering is fixed
-            // eslint-disable-next-line @jessie.js/no-nested-await
-            const vaultKit = await vault.initVaultKit(seat, vaultStorageNode);
-            // initVaultKit calls back to handleBalanceChange() which will add the
-            // vault to prioritizedVaults
-
-            // initVaultKit doesn't write to the storage node until it's returning
-            // so if it returned then we know the node key was consumed
-            state.vaultCounter += 1;
-
-            return vaultKit;
-          } catch (err) {
-            console.error(
-              'attempting recovery after initVaultKit failure',
-              err,
-            );
-            // ??? do we still need this cleanup? it won't get into the store unless it has collateral,
-            // which should qualify it to be in the store. If we drop this catch then the nested await
-            // for `vault.initVaultKit()` goes away.
-
-            // remove it from the store if it got in
-            /** @type {NormalizedDebt} */
-            // @ts-expect-error cast
-            const normalizedDebt = AmountMath.makeEmpty(state.debtBrand);
-            const collateralPre = seat.getCurrentAllocation().Collateral;
-            const { prioritizedVaults } = collateralEphemera(
-              state.collateralBrand,
-            );
-            try {
-              prioritizedVaults.removeVaultByAttributes(
-                normalizedDebt,
-                collateralPre,
-                vaultId,
-              );
-              console.warn(
-                'removed vault',
-                vaultId,
-                'after initVaultKit failure',
-              );
-            } catch {
-              console.info(
-                'vault',
-                vaultId,
-                'never stored during initVaultKit failure',
-              );
-            }
-            throw err;
-          } finally {
-            if (!seat.hasExited()) {
-              seat.exit();
-            }
-          }
-        },
-
-        getCollateralQuote() {
-          const { storedCollateralQuote } = collateralEphemera(
-            this.state.collateralBrand,
-          );
-          if (!storedCollateralQuote)
-            throw Fail`getCollateralQuote called before a collateral quote was available`;
-          return storedCollateralQuote;
-        },
-
-        getPublicFacet() {
-          return this.facets.collateral;
-        },
-
-        lockOraclePrices() {
-          const { state, facets } = this;
-          const { storedCollateralQuote } = collateralEphemera(
-            state.collateralBrand,
-          );
-          if (!storedCollateralQuote)
-            throw Fail`lockOraclePrices called before a collateral quote was available`;
-          trace(
-            `lockPrice`,
-            getAmountIn(storedCollateralQuote),
-            getAmountOut(storedCollateralQuote),
-          );
-
-          state.lockedQuote = storedCollateralQuote;
-          facets.helper.writeMetrics();
-          return storedCollateralQuote;
-        },
-        /**
-         * @param {AuctioneerPublicFacet} auctionPF
-         */
-        async liquidateVaults(auctionPF) {
-          const { state, facets } = this;
-          const { self, helper } = facets;
-          const {
-            collateralBrand,
-            compoundedInterest,
-            debtBrand,
-            liquidatingVaults,
-            lockedQuote,
-          } = state;
-          trace(collateralBrand, 'considering liquidation');
-
-          const { prioritizedVaults } = collateralEphemera(collateralBrand);
-          assert(factoryPowers && prioritizedVaults && zcf);
-          lockedQuote ||
-            Fail`Must have locked a quote before liquidating vaults.`;
-          assert(lockedQuote); // redundant with previous line
-
-          const liqMargin = self.getGovernedParams().getLiquidationMargin();
-
-          // totals *among* vaults being liquidated
-          const { totalDebt, totalCollateral, vaultData, liqSeat } =
-            getLiquidatableVaults(
-              zcf,
-              {
-                quote: lockedQuote,
-                interest: compoundedInterest,
-                margin: liqMargin,
-              },
-              prioritizedVaults,
-              liquidatingVaults,
-              debtBrand,
-              collateralBrand,
-            );
-          // reset lockedQuote after we've used it for the liquidation decision
-          state.lockedQuote = undefined;
-
-          if (vaultData.getSize() === 0) {
-            return;
-          }
-          trace(
-            ' Found vaults to liquidate',
-            liquidatingVaults.getSize(),
-            totalCollateral,
-          );
-
-          helper.markLiquidating(totalDebt, totalCollateral);
-          void helper.writeMetrics();
-
-          const { userSeatPromise, deposited } = await E.when(
-            E(auctionPF).makeDepositInvitation(),
-            depositInvitation =>
-              offerTo(
-                zcf,
-                depositInvitation,
-                harden({ Minted: 'Bid' }),
-                harden({ give: { Collateral: totalCollateral } }),
-                liqSeat,
-                liqSeat,
-                { goal: totalDebt },
-              ),
-          );
-
-          // This is expected to wait for the duration of the auction, which
-          // is controlled by the auction parameters startFrequency, clockStep,
-          // and the difference between startingRate and lowestRate.
-          const [proceeds] = await Promise.all([deposited, userSeatPromise]);
-
-          const { storedCollateralQuote } = collateralEphemera(
-            this.state.collateralBrand,
-          );
-
-          trace(`LiqV after long wait`, proceeds);
-          try {
-            const { plan, vaultsInPlan } = helper.planProceedsDistribution(
-              proceeds,
-              totalDebt,
-              storedCollateralQuote,
-              vaultData,
-              totalCollateral,
-            );
-            trace('PLAN', plan);
-            // distributeProceeds may reconstitute vaults, removing them from liquidatingVaults
-            helper.distributeProceeds({
-              liqSeat,
-              plan,
-              totalCollateral,
-              totalDebt,
-              vaultsInPlan,
-            });
-          } catch (err) {
-            console.error('🚨 Error distributing proceeds:', err);
-          }
-
-          // for all non-reconstituted vaults, transition to 'liquidated' state
-          state.numLiquidationsCompleted += liquidatingVaults.getSize();
-          for (const vault of liquidatingVaults.values()) {
-            vault.liquidated();
-            liquidatingVaults.delete(vault);
-          }
-
-          await facets.helper.writeMetrics();
-        },
-      },
-    },
-
-    {
-      finish: ({ state, facets: { helper } }) => {
-        helper.start();
-        void state.assetTopicKit.recorder.write(
-          harden({
-            compoundedInterest: state.compoundedInterest,
-            interestRate: factoryPowers
-              .getGovernedParams(state.collateralBrand)
-              .getInterestRate(),
-            latestInterestUpdate: state.latestInterestUpdate,
-          }),
-        );
-
-        // push initial state of metrics
-        void helper.writeMetrics();
-      },
-    },
-  );
-
-  /** @param {Omit<Parameters<typeof makeVaultManagerKitInternal>[0], 'metricsStorageNode'>} externalParams */
-  const makeVaultManagerKit = async externalParams => {
-    const metricsStorageNode = await E(
-      externalParams.storageNode,
-    ).makeChildNode('metrics');
-    return makeVaultManagerKitInternal({
-      ...externalParams,
-      metricsStorageNode,
-    });
-  };
-  return makeVaultManagerKit;
-};
-
-/**
- * @typedef {Awaited<ReturnType<ReturnType<typeof prepareVaultManagerKit>>>} VaultManagerKit
- */
-/**
- * @typedef {VaultManagerKit['self']} VaultManager
- * Each VaultManager manages a single collateral type.
- *
- * It manages some number of outstanding debt positions, each called a Vault,
- * for which the collateral is provided in exchange for borrowed Minted.
- */
-/** @typedef {VaultManagerKit['collateral']} CollateralManager */
-
-/**
- * Support restarting kits from baggage and mutating the array holding them
- *
- * @param {import('@agoric/vat-data').Baggage} baggage
- */
-export const provideAndStartVaultManagerKits = baggage => {
-  trace('provideAndStartVaultManagerKits start');
-  const key = 'vaultManagerKits';
-
-  const noKits = /** @type {VaultManagerKit[]} */ (harden([]));
-
-  for (const kit of provide(baggage, key, () => noKits)) {
-    kit.helper.start();
-  }
-
-  trace('provideAndStartVaultManagerKits returning');
-  return {
-    /** @type {(kit: VaultManagerKit) => void} */
-    add: kit => {
-      appendToStoredArray(baggage, key, kit);
-    },
-    /** @type {(index: number) => VaultManagerKit} */
-    get: index => {
-      const kits = baggage.get(key);
-      index < kits.length || Fail`no VaultManagerKit at index ${index}`;
-      return kits[index];
-    },
-    length: () => baggage.get(key).length,
-  };
-};
-harden(provideAndStartVaultManagerKits);
diff --git a/packages/vats/test/bootstrapTests/liquidationVisibility/vaults-liquidation-config.json b/packages/vats/test/bootstrapTests/liquidationVisibility/vaults-liquidation-config.json
deleted file mode 100644
index b8bed0ba71b..00000000000
--- a/packages/vats/test/bootstrapTests/liquidationVisibility/vaults-liquidation-config.json
+++ /dev/null
@@ -1,228 +0,0 @@
-{
-  "$comment": "This SwingSet config file (see loadSwingsetConfigFile) is designed to bring up vaults test networks in an automated fashion. It includes coreProposals to start vaults. Testing facilities are limited to an initialPrice for ATOM and addresses with known keys.",
-  "bootstrap": "bootstrap",
-  "defaultReapInterval": 1000,
-  "coreProposals": [
-    "@agoric/vats/scripts/init-core.js",
-    {
-      "module": "@agoric/vats/test/bootstrapTests/liquidationVisibility/init-old-vaultFactory.js",
-      "entrypoint": "defaultProposalBuilder",
-      "args": [
-        {
-          "econCommitteeOptions": {
-            "committeeSize": 6
-          },
-          "referencedUi": "NO REFERENCED UI",
-          "minInitialPoolLiquidity": "0"
-        }
-      ]
-    },
-    {
-      "module": "@agoric/inter-protocol/scripts/add-collateral-core.js",
-      "entrypoint": "defaultProposalBuilder",
-      "args": [
-        {
-          "interchainAssetOptions": {
-            "denom": "ibc/BA313C4A19DFBF943586C0387E6B11286F9E416B4DD27574E6909CABE0E342FA",
-            "decimalPlaces": 6,
-            "keyword": "ATOM",
-            "oracleBrand": "ATOM",
-            "proposedName": "ATOM"
-          }
-        }
-      ]
-    },
-    {
-      "module": "@agoric/inter-protocol/scripts/add-collateral-core.js",
-      "entrypoint": "psmProposalBuilder",
-      "args": [
-        {
-          "anchorOptions": {
-            "denom": "ibc/295548A78785A1007F232DE286149A6FF512F180AF5657780FC89C009E2C348F",
-            "decimalPlaces": 6,
-            "keyword": "USDC_axl",
-            "proposedName": "USD Coin"
-          }
-        }
-      ]
-    },
-    {
-      "module": "@agoric/inter-protocol/scripts/add-collateral-core.js",
-      "entrypoint": "psmProposalBuilder",
-      "args": [
-        {
-          "anchorOptions": {
-            "denom": "ibc/6831292903487E58BF9A195FDDC8A2E626B3DF39B88F4E7F41C935CADBAF54AC",
-            "decimalPlaces": 6,
-            "keyword": "USDC_grv",
-            "proposedName": "USC Coin"
-          }
-        }
-      ]
-    },
-    {
-      "module": "@agoric/inter-protocol/scripts/add-collateral-core.js",
-      "entrypoint": "psmProposalBuilder",
-      "args": [
-        {
-          "anchorOptions": {
-            "denom": "ibc/F2331645B9683116188EF36FC04A809C28BD36B54555E8705A37146D0182F045",
-            "decimalPlaces": 6,
-            "keyword": "USDT_axl",
-            "proposedName": "Tether USD"
-          }
-        }
-      ]
-    },
-    {
-      "module": "@agoric/inter-protocol/scripts/add-collateral-core.js",
-      "entrypoint": "psmProposalBuilder",
-      "args": [
-        {
-          "anchorOptions": {
-            "denom": "ibc/386D09AE31DA7C0C93091BB45D08CB7A0730B1F697CD813F06A5446DCF02EEB2",
-            "decimalPlaces": 6,
-            "keyword": "USDT_grv",
-            "proposedName": "Tether USD"
-          }
-        }
-      ]
-    },
-    {
-      "module": "@agoric/inter-protocol/scripts/add-collateral-core.js",
-      "entrypoint": "psmProposalBuilder",
-      "args": [
-        {
-          "anchorOptions": {
-            "denom": "ibc/3914BDEF46F429A26917E4D8D434620EC4817DC6B6E68FB327E190902F1E9242",
-            "decimalPlaces": 18,
-            "keyword": "DAI_axl",
-            "proposedName": "DAI"
-          }
-        }
-      ]
-    },
-    {
-      "module": "@agoric/inter-protocol/scripts/add-collateral-core.js",
-      "entrypoint": "psmProposalBuilder",
-      "args": [
-        {
-          "anchorOptions": {
-            "denom": "ibc/3D5291C23D776C3AA7A7ABB34C7B023193ECD2BC42EA19D3165B2CF9652117E7",
-            "decimalPlaces": 18,
-            "keyword": "DAI_grv",
-            "proposedName": "DAI"
-          }
-        }
-      ]
-    },
-    {
-      "module": "@agoric/inter-protocol/scripts/price-feed-core.js",
-      "entrypoint": "defaultProposalBuilder",
-      "args": [
-        {
-          "contractTerms": {
-            "POLL_INTERVAL": 30,
-            "maxSubmissionCount": 1000,
-            "minSubmissionCount": 3,
-            "restartDelay": 1,
-            "timeout": 10,
-            "minSubmissionValue": 1,
-            "maxSubmissionValue": 9007199254740991
-          },
-          "AGORIC_INSTANCE_NAME": "ATOM-USD price feed",
-          "oracleAddresses": [
-            "agoric1krunjcqfrf7la48zrvdfeeqtls5r00ep68mzkr",
-            "agoric19uscwxdac6cf6z7d5e26e0jm0lgwstc47cpll8",
-            "agoric144rrhh4m09mh7aaffhm6xy223ym76gve2x7y78",
-            "agoric19d6gnr9fyp6hev4tlrg87zjrzsd5gzr5qlfq2p",
-            "agoric1n4fcxsnkxe4gj6e24naec99hzmc4pjfdccy5nj"
-          ],
-          "IN_BRAND_LOOKUP": [
-            "agoricNames",
-            "oracleBrand",
-            "ATOM"
-          ],
-          "IN_BRAND_DECIMALS": 6,
-          "OUT_BRAND_LOOKUP": [
-            "agoricNames",
-            "oracleBrand",
-            "USD"
-          ],
-          "OUT_BRAND_DECIMALS": 4
-        }
-      ]
-    },
-    {
-      "module": "@agoric/inter-protocol/scripts/invite-committee-core.js",
-      "entrypoint": "defaultProposalBuilder",
-      "args": [
-        {
-          "voterAddresses": {
-            "Jason Potts": "agoric1gx9uu7y6c90rqruhesae2t7c2vlw4uyyxlqxrx",
-            "Chloe White": "agoric1d4228cvelf8tj65f4h7n2td90sscavln2283h5",
-            "Thibault Schrepel": "agoric14543m33dr28x7qhwc558hzlj9szwhzwzpcmw6a",
-            "Chris Berg": "agoric13p9adwk0na5npfq64g22l6xucvqdmu3xqe70wq",
-            "Youssef Amrani": "agoric1el6zqs8ggctj5vwyukyk4fh50wcpdpwgugd5l5",
-            "Joe Clark": "agoric1zayxg4e9vd0es9c9jlpt36qtth255txjp6a8yc"
-          }
-        }
-      ]
-    }
-  ],
-  "vats": {
-    "bootstrap": {
-      "sourceSpec": "@agoric/vats/src/core/boot-chain.js",
-      "creationOptions": {
-        "critical": true
-      }
-    }
-  },
-  "clearStorageSubtrees": [
-    "published"
-  ],
-  "exportStorageSubtrees": [
-    "published.psm.IST",
-    "published.wallet",
-    "published.provisionPool.metrics"
-  ],
-  "bundles": {
-    "agoricNames": {
-      "sourceSpec": "@agoric/vats/src/vat-agoricNames.js"
-    },
-    "bank": {
-      "sourceSpec": "@agoric/vats/src/vat-bank.js"
-    },
-    "board": {
-      "sourceSpec": "@agoric/vats/src/vat-board.js"
-    },
-    "bridge": {
-      "sourceSpec": "@agoric/vats/src/vat-bridge.js"
-    },
-    "centralSupply": {
-      "sourceSpec": "@agoric/vats/src/centralSupply.js"
-    },
-    "mintHolder": {
-      "sourceSpec": "@agoric/vats/src/mintHolder.js"
-    },
-    "priceAuthority": {
-      "sourceSpec": "@agoric/vats/src/vat-priceAuthority.js"
-    },
-    "provisionPool": {
-      "sourceSpec": "@agoric/vats/src/provisionPool.js"
-    },
-    "provisioning": {
-      "sourceSpec": "@agoric/vats/src/vat-provisioning.js"
-    },
-    "walletFactory": {
-      "sourceSpec": "@agoric/smart-wallet/src/walletFactory.js"
-    },
-    "zcf": {
-      "sourceSpec": "@agoric/zoe/contractFacet.js"
-    },
-    "zoe": {
-      "sourceSpec": "@agoric/vats/src/vat-zoe.js"
-    }
-  },
-  "defaultManagerType": "xs-worker"
-}
\ No newline at end of file