@agoric/inter-protocol 0.13.3 → 0.13.4-dev-d32a66a.0

package/src/proposals/econ-behaviors.js

@@ -1,76 +1,67 @@
-// @ts-check
+// @jessie-check
 
 import '../../exported.js';
 
 import { AmountMath } from '@agoric/ertp';
 import '@agoric/governance/exported.js';
+import { deeplyFulfilledObject, makeTracer } from '@agoric/internal';
+import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
 import '@agoric/vats/exported.js';
 import '@agoric/vats/src/core/types.js';
-import { makeStorageNodeChild } from '@agoric/vats/src/lib-chainStorage.js';
-import { makeRatio } from '@agoric/zoe/src/contractSupport/index.js';
-import { E, Far } from '@endo/far';
-import { Stable, Stake } from '@agoric/vats/src/tokens.js';
-import { deeplyFulfilledObject } from '@agoric/internal';
-import * as Collect from '../collect.js';
-import { makeTracer } from '../makeTracer.js';
-import { makeStakeReporter } from '../my-lien.js';
+import { Stable } from '@agoric/vats/src/tokens.js';
+import { E } from '@endo/far';
+import { makeScalarBigMapStore } from '@agoric/vat-data';
+import { makeGovernedTerms as makeGovernedATerms } from '../auction/params.js';
 import { makeReserveTerms } from '../reserve/params.js';
-import { makeStakeFactoryTerms } from '../stakeFactory/params.js';
-import { liquidationDetailTerms } from '../vaultFactory/liquidation.js';
-import { makeGovernedTerms } from '../vaultFactory/params.js';
-import { makeAmmTerms } from '../vpool-xyk-amm/params.js';
+import { makeGovernedTerms as makeGovernedVFTerms } from '../vaultFactory/params.js';
 
-const trace = makeTracer('RunEconBehaviors', false);
+const trace = makeTracer('RunEconBehaviors', true);
 
-const { details: X } = assert;
-
-const SECONDS_PER_HOUR = 60n * 60n;
-const SECONDS_PER_DAY = 24n * SECONDS_PER_HOUR;
-
-const BASIS_POINTS = 10_000n;
-const MILLI = 1_000_000n;
+export const SECONDS_PER_HOUR = 60n * 60n;
+export const SECONDS_PER_DAY = 24n * SECONDS_PER_HOUR;
+export const SECONDS_PER_WEEK = 7n * SECONDS_PER_DAY;
 
 /**
- * @typedef {GovernedCreatorFacet<import('../stakeFactory/stakeFactory.js').StakeFactoryCreator>} StakeFactoryCreator
- * @typedef {import('../stakeFactory/stakeFactory.js').StakeFactoryPublic} StakeFactoryPublic
- * @typedef {import('../reserve/assetReserve.js').GovernedAssetReserveFacetAccess} GovernedAssetReserveFacetAccess
+ * @typedef {import('../vaultFactory/vaultFactory.js').VaultFactoryContract['publicFacet']} VaultFactoryPublicFacet
+ * @typedef {import('../auction/auctioneer.js').AuctioneerPublicFacet} AuctioneerPublicFacet
+ * @typedef {import('../auction/auctioneer.js').AuctioneerCreatorFacet} AuctioneerCreatorFacet
  */
 
 /**
- * @typedef {object} PSMFacets
+ * @typedef {object} PSMKit
+ * @property {string} label
  * @property {Instance} psm
  * @property {Instance} psmGovernor
- * @property {Awaited<ReturnType<import('../psm/psm.js').start>>['creatorFacet']} psmCreatorFacet
- * @property {GovernedContractFacetAccess<{},{}>} psmGovernorCreatorFacet
+ * @property {Awaited<ReturnType<Awaited<ReturnType<import('../psm/psm.js')['prepare']>>['creatorFacet']['getLimitedCreatorFacet']>>} psmCreatorFacet
+ * @property {GovernorCreatorFacet<import('../../src/psm/psm.js')['prepare']>} psmGovernorCreatorFacet
  * @property {AdminFacet} psmAdminFacet
  */
 
+/**
+ * @typedef {GovernanceFacetKit<import('../auction/auctioneer.js').start>} AuctioneerKit
+ */
+
 /**
  * @typedef { WellKnownSpaces & ChainBootstrapSpace & EconomyBootstrapSpace
  * } EconomyBootstrapPowers
  * @typedef {PromiseSpaceOf<{
- *   ammInstanceWithoutReserve: Instance,
- *   ammCreatorFacet: XYKAMMCreatorFacet,
- *   ammGovernorCreatorFacet: GovernedContractFacetAccess<XYKAMMPublicFacet,XYKAMMCreatorFacet>,
- *   economicCommitteeCreatorFacet: CommitteeElectorateCreatorFacet,
- *   feeDistributorCreatorFacet: import('../feeDistributor.js').FeeDistributorCreatorFacet,
- *   feeDistributorPublicFacet: import('../feeDistributor.js').FeeDistributorPublicFacet,
- *   periodicFeeCollectors: import('../feeDistributor.js').PeriodicFeeCollector[],
- *   bankMints: Mint[],
- *   psmFacets: MapStore<Brand, PSMFacets>,
- *   psmCharterCreatorFacet: Awaited<ReturnType<import('../psm/psmCharter.js').start>>['creatorFacet'],
- *   psmCharterAdminFacet: AdminFacet,
- *   reservePublicFacet: import('../reserve/assetReserve.js').AssetReservePublicFacet,
- *   reserveCreatorFacet: import('../reserve/assetReserve.js').AssetReserveLimitedCreatorFacet,
- *   reserveGovernorCreatorFacet: GovernedAssetReserveFacetAccess,
- *   stakeFactoryCreatorFacet: StakeFactoryCreator,
- *   vaultFactoryCreator: VaultFactoryCreatorFacet,
- *   vaultFactoryGovernorCreator: GovernedContractFacetAccess<{},{}>,
- *   vaultFactoryVoteCreator: unknown,
+ *   economicCommitteeKit: CommitteeStartResult,
+ *   economicCommitteeCreatorFacet: import('@agoric/governance/src/committee.js').CommitteeElectorateCreatorFacet,
+ *   feeDistributorKit: StartedInstanceKit<typeof import('../feeDistributor.js').start>,
+ *   periodicFeeCollectors: MapStore<number, import('../feeDistributor.js').PeriodicFeeCollector>,
+ *   psmKit: MapStore<Brand, PSMKit>,
+ *   anchorBalancePayments: MapStore<Brand, Payment<'nat'>>,
+ *   econCharterKit: EconCharterStartResult,
+ *   reserveKit: GovernanceFacetKit<import('../reserve/assetReserve.js')['prepare']>,
+ *   vaultFactoryKit: GovernanceFacetKit<import('../vaultFactory/vaultFactory.js')['prepare']>,
+ *   auctioneerKit: AuctioneerKit,
  *   minInitialDebt: NatValue,
  * }>} EconomyBootstrapSpace
  */
 
+/** @typedef {import('@agoric/zoe/src/zoeService/utils.js').StartedInstanceKit<import('../econCommitteeCharter')['prepare']>} EconCharterStartResult */
+/** @typedef {import('@agoric/zoe/src/zoeService/utils.js').StartedInstanceKit<import('@agoric/governance/src/committee.js')['prepare']>} CommitteeStartResult */
+
 /**
  * @file A collection of productions, each of which declares inputs and outputs.
  * Each function is passed a set of powers for reading from and writing to the vat config.
@@ -80,184 +71,23 @@ const MILLI = 1_000_000n;
  * In production called by @agoric/vats to bootstrap.
  */
 
-/**
- * @param {EconomyBootstrapPowers} powers
- * @param {{
- *   interchainPoolOptions?: { minimumCentral?: bigint }
- * }} [options]
- */
-export const startInterchainPool = async (
-  {
-    consume: { bankManager: mgrP, zoe, agoricNamesAdmin },
-    installation: {
-      consume: { interchainPool: installation },
-    },
-    instance: {
-      consume: { amm },
-      produce: { interchainPool: _viaAgoricNamesAdmin },
-    },
-    brand: {
-      consume: { [Stable.symbol]: centralBrandP },
-    },
-    issuer: {
-      consume: { [Stable.symbol]: centralIssuerP },
-    },
-  },
-  { interchainPoolOptions = {} } = {},
-) => {
-  trace('startInterchainPool');
-  // TODO: get minimumCentral dynamically from the AMM
-  const { minimumCentral = 100n * MILLI } = interchainPoolOptions;
-  const [centralIssuer, centralBrand, bankManager] = await Promise.all([
-    centralIssuerP,
-    centralBrandP,
-    mgrP,
-  ]);
-
-  const terms = await deeplyFulfilledObject(
-    harden({
-      minimumCentral: AmountMath.make(centralBrand, minimumCentral),
-      amm,
-    }),
-  );
-  const { instance } = await E(zoe).startInstance(
-    installation,
-    { Central: centralIssuer },
-    terms,
-    {
-      bankManager,
-    },
-  );
-
-  const instanceAdmin = E(agoricNamesAdmin).lookupAdmin('instance');
-  await E(instanceAdmin).update('interchainPool', instance);
-};
-harden(startInterchainPool);
-
-const AMM_STORAGE_PATH = 'amm'; // TODO: share with agoricNames?
-
-/**
- * @param {EconomyBootstrapPowers} powers
- * @param {{ options?: { minInitialPoolLiquidity?: bigint }}} opts
- */
-export const setupAmm = async (
-  {
-    consume: {
-      board,
-      chainTimerService,
-      zoe,
-      economicCommitteeCreatorFacet: committeeCreator,
-      chainStorage,
-    },
-    produce: {
-      ammCreatorFacet,
-      ammInstanceWithoutReserve,
-      ammGovernorCreatorFacet,
-    },
-    brand: {
-      consume: { [Stable.symbol]: runBrandP },
-    },
-    issuer: {
-      consume: { [Stable.symbol]: centralIssuer },
-    },
-    instance: {
-      produce: { ammGovernor },
-    },
-    installation: {
-      consume: { contractGovernor: governorInstallation, amm: ammInstallation },
-    },
-  },
-  { options = {} } = {},
-) => {
-  trace('setupAmm');
-
-  const poserInvitationP = E(committeeCreator).getPoserInvitation();
-  const [poserInvitation, runBrand] = await Promise.all([
-    poserInvitationP,
-    runBrandP,
-  ]);
-  const { minInitialPoolLiquidity = 1_000_000_000n } = options;
-
-  const ammTerms = makeAmmTerms(
-    chainTimerService,
-    E(E(zoe).getInvitationIssuer()).getAmountOf(poserInvitationP),
-    AmountMath.make(runBrand, minInitialPoolLiquidity),
-  );
-
-  const storageNode = await makeStorageNodeChild(
-    chainStorage,
-    AMM_STORAGE_PATH,
-  );
-  const marshaller = await E(board).getPublishingMarshaller();
-
-  const ammGovernorTerms = await deeplyFulfilledObject(
-    harden({
-      timer: chainTimerService,
-      governedContractInstallation: ammInstallation,
-      governed: {
-        terms: ammTerms,
-        issuerKeywordRecord: { Central: centralIssuer },
-      },
-    }),
-  );
-
-  /** @type {{ creatorFacet: GovernedContractFacetAccess<XYKAMMPublicFacet,XYKAMMCreatorFacet>, publicFacet: GovernorPublic, instance: Instance }} */
-  const g = await E(zoe).startInstance(
-    governorInstallation,
-    {},
-    ammGovernorTerms,
-    {
-      electorateCreatorFacet: committeeCreator,
-      governed: {
-        initialPoserInvitation: poserInvitation,
-        storageNode,
-        marshaller,
-      },
-    },
-  );
-
-  const [creatorFacet, ammPublicFacet, instance] = await Promise.all([
-    E(g.creatorFacet).getCreatorFacet(),
-    E(g.creatorFacet).getPublicFacet(),
-    E(g.publicFacet).getGovernedContract(),
-  ]);
-  ammGovernorCreatorFacet.resolve(g.creatorFacet);
-  ammCreatorFacet.resolve(creatorFacet);
-
-  // Confirm that the amm was indeed setup
-  assert(ammPublicFacet, X`ammPublicFacet broken  ${ammPublicFacet}`);
-
-  ammInstanceWithoutReserve.resolve(instance);
-  ammGovernor.resolve(g.instance);
-  return ammInstallation;
-};
-
 /** @param {EconomyBootstrapPowers} powers */
 export const setupReserve = async ({
   consume: {
-    ammCreatorFacet,
-    ammInstanceWithoutReserve,
     board,
     feeMintAccess: feeMintAccessP,
     chainStorage,
     chainTimerService,
+    diagnostics,
     zoe,
     economicCommitteeCreatorFacet: committeeCreator,
   },
-  produce: {
-    reserveCreatorFacet,
-    reserveGovernorCreatorFacet,
-    reservePublicFacet,
-  },
+  produce: { reserveKit },
   issuer: {
     consume: { [Stable.symbol]: centralIssuer },
   },
   instance: {
-    produce: {
-      amm: ammInstanceProducer,
-      reserve: reserveInstanceProducer,
-      reserveGovernor,
-    },
+    produce: { reserve: reserveInstanceProducer, reserveGovernor },
   },
   installation: {
     consume: {
@@ -269,6 +99,7 @@ export const setupReserve = async ({
   const STORAGE_PATH = 'reserve';
   trace('setupReserve');
   const poserInvitationP = E(committeeCreator).getPoserInvitation();
+
   const [poserInvitation, poserInvitationAmount, feeMintAccess] =
     await Promise.all([
       poserInvitationP,
@@ -276,14 +107,11 @@ export const setupReserve = async ({
       feeMintAccessP,
     ]);
 
-  const reserveTerms = makeReserveTerms(
-    poserInvitationAmount,
-    ammInstanceWithoutReserve,
-  );
-
   const storageNode = await makeStorageNodeChild(chainStorage, STORAGE_PATH);
   const marshaller = await E(board).getReadonlyMarshaller();
 
+  const reserveTerms = makeReserveTerms(poserInvitationAmount);
+
   const reserveGovernorTerms = await deeplyFulfilledObject(
     harden({
       timer: chainTimerService,
@@ -291,23 +119,25 @@ export const setupReserve = async ({
       governed: {
         terms: reserveTerms,
         issuerKeywordRecord: { Central: centralIssuer },
+        label: 'reserve',
       },
     }),
   );
-  /** @type {{ creatorFacet: GovernedAssetReserveFacetAccess, publicFacet: GovernorPublic, instance: Instance }} */
+  const privateArgs = {
+    governed: {
+      feeMintAccess,
+      initialPoserInvitation: poserInvitation,
+      marshaller,
+      storageNode,
+    },
+  };
+  /** @type {GovernorStartedInstallationKit<typeof reserveInstallation>} */
   const g = await E(zoe).startInstance(
     governorInstallation,
     {},
     reserveGovernorTerms,
-    {
-      electorateCreatorFacet: committeeCreator,
-      governed: {
-        feeMintAccess,
-        initialPoserInvitation: poserInvitation,
-        marshaller,
-        storageNode,
-      },
-    },
+    privateArgs,
+    'reserve.governor',
   );
 
   const [creatorFacet, publicFacet, instance] = await Promise.all([
@@ -316,159 +146,206 @@ export const setupReserve = async ({
     E(g.publicFacet).getGovernedContract(),
   ]);
 
-  reserveGovernorCreatorFacet.resolve(g.creatorFacet);
-  reserveCreatorFacet.resolve(creatorFacet);
-  reservePublicFacet.resolve(publicFacet);
+  reserveKit.resolve(
+    harden({
+      label: 'AssetReserve',
+      instance,
+      publicFacet,
+      creatorFacet,
+      adminFacet: g.adminFacet,
+
+      governor: g.instance,
+      governorCreatorFacet: g.creatorFacet,
+      governorAdminFacet: g.adminFacet,
+    }),
+  );
+  await E(diagnostics).savePrivateArgs(instance, privateArgs.governed);
+  await E(diagnostics).savePrivateArgs(g.instance, privateArgs);
 
   reserveInstanceProducer.resolve(instance);
   reserveGovernor.resolve(g.instance);
 
-  // AMM requires Reserve in order to add pools, but we can't provide it at startInstance
-  // time because Reserve requires AMM itself in order to be started.
-  // Now that we have the reserve, provide it to the AMM.
-  trace('Resolving the reserve public facet on the AMM');
-  await E(ammCreatorFacet).resolveReserveFacet(publicFacet);
-  // it now has the reserve
-  ammInstanceProducer.resolve(ammInstanceWithoutReserve);
-
   return reserveInstallation;
 };
 
 /**
- * @param {EconomyBootstrapPowers} powers
+ * @param {EconomyBootstrapPowers['consume']} consume
  * @param {object} config
- * @param {LoanTiming} [config.loanParams]
- * @param {bigint} minInitialDebt
+ * @param {InterestTiming} [config.interestTiming]
+ * @param {object} [config.options]
+ * @param {string} [config.options.endorsedUi]
+ * @param {Amount<'nat'>} minInitialDebt
  */
-export const startVaultFactory = async (
-  {
-    consume: {
-      board,
-      chainStorage,
-      chainTimerService,
-      priceAuthority,
-      zoe,
-      feeMintAccess: feeMintAccessP,
-      economicCommitteeCreatorFacet: electorateCreatorFacet,
-      reserveCreatorFacet,
-    },
-    produce, // {  vaultFactoryCreator }
-    brand: {
-      consume: { [Stable.symbol]: centralBrandP },
-    },
-    instance: {
-      produce: instanceProduce,
-      consume: { amm: ammInstance, reserve: reserveInstance },
-    },
-    installation: {
-      consume: {
-        VaultFactory: vaultFactoryInstallation,
-        liquidate: liquidateInstallationP,
-        contractGovernor: contractGovernorInstallation,
-      },
-    },
-  },
+export const setupVaultFactoryArguments = async (
+  consume,
   {
-    loanParams = {
+    interestTiming = {
       chargingPeriod: SECONDS_PER_HOUR,
       recordingPeriod: SECONDS_PER_DAY,
     },
+    options: { endorsedUi } = {},
   } = {},
-  minInitialDebt = 5_000_000n,
+  minInitialDebt,
 ) => {
   const STORAGE_PATH = 'vaultFactory';
-  trace('startVaultFactory');
+  trace('setupVaultFactory');
+
+  const {
+    board,
+    chainStorage,
+    chainTimerService,
+    priceAuthority,
+    zoe,
+    feeMintAccess: feeMintAccessP,
+    economicCommitteeCreatorFacet: electorateCreatorFacet,
+    reserveKit,
+    auctioneerKit,
+  } = consume;
 
   const poserInvitationP = E(electorateCreatorFacet).getPoserInvitation();
-  const shortfallInvitationP =
-    E(reserveCreatorFacet).makeShortfallReportingInvitation();
+  const shortfallInvitationP = E(
+    E.get(reserveKit).creatorFacet,
+  ).makeShortfallReportingInvitation();
+
   const [
     initialPoserInvitation,
     poserInvitationAmount,
     initialShortfallInvitation,
     shortfallInvitationAmount,
-    liquidateInstallation,
     feeMintAccess,
+    auctioneerPublicFacet,
   ] = await Promise.all([
     poserInvitationP,
     E(E(zoe).getInvitationIssuer()).getAmountOf(poserInvitationP),
     shortfallInvitationP,
     E(E(zoe).getInvitationIssuer()).getAmountOf(shortfallInvitationP),
-    liquidateInstallationP,
     feeMintAccessP,
+    E.get(auctioneerKit).publicFacet,
   ]);
 
-  const centralBrand = await centralBrandP;
-
-  const ammPublicFacet = await E(zoe).getPublicFacet(ammInstance);
-  const reservePublicFacet = await E(zoe).getPublicFacet(reserveInstance);
+  const reservePublicFacet = await E.get(reserveKit).publicFacet;
   const storageNode = await makeStorageNodeChild(chainStorage, STORAGE_PATH);
   const marshaller = await E(board).getReadonlyMarshaller();
 
-  const vaultFactoryTerms = makeGovernedTerms(
-    { storageNode, marshaller },
-    {
-      priceAuthority,
-      reservePublicFacet,
-      loanTiming: loanParams,
-      liquidationInstall: liquidateInstallation,
-      timer: chainTimerService,
-      electorateInvitationAmount: poserInvitationAmount,
-      ammPublicFacet,
-      liquidationTerms: liquidationDetailTerms(centralBrand),
-      minInitialDebt: AmountMath.make(centralBrand, minInitialDebt),
-      bootstrapPaymentValue: 0n,
-      shortfallInvitationAmount,
+  const vaultFactoryTerms = makeGovernedVFTerms({
+    priceAuthority,
+    auctioneerPublicFacet,
+    reservePublicFacet,
+    interestTiming,
+    timer: chainTimerService,
+    electorateInvitationAmount: poserInvitationAmount,
+    minInitialDebt,
+    bootstrapPaymentValue: 0n,
+    shortfallInvitationAmount,
+    endorsedUi,
+  });
+
+  const vaultFactoryPrivateArgs = {
+    feeMintAccess,
+    initialPoserInvitation,
+    initialShortfallInvitation,
+    marshaller,
+    storageNode,
+  };
+
+  return { vaultFactoryTerms, vaultFactoryPrivateArgs };
+};
+
+/**
+ * @param {EconomyBootstrapPowers} powers
+ * @param {object} config
+ * @param {InterestTiming} [config.interestTiming]
+ * @param {object} [config.options]
+ * @param {string} [config.options.endorsedUi]
+ * @param {bigint} minInitialDebt
+ */
+export const startVaultFactory = async (
+  {
+    consume,
+    produce: { vaultFactoryKit },
+    brand: {
+      consume: { [Stable.symbol]: centralBrandP },
     },
-  );
+    instance: { produce: instanceProduce },
+    installation: {
+      consume: {
+        VaultFactory: vaultFactoryInstallation,
+        contractGovernor: contractGovernorInstallation,
+      },
+    },
+  },
+  config,
+  minInitialDebt = 5_000_000n,
+) => {
+  trace('startVaultFactory');
+
+  const centralBrand = await centralBrandP;
+
+  const { vaultFactoryTerms, vaultFactoryPrivateArgs } =
+    await setupVaultFactoryArguments(
+      consume,
+      config,
+      AmountMath.make(centralBrand, minInitialDebt),
+    );
 
   const governorTerms = await deeplyFulfilledObject(
     harden({
-      timer: chainTimerService,
+      timer: consume.chainTimerService,
       governedContractInstallation: vaultFactoryInstallation,
       governed: {
         terms: vaultFactoryTerms,
         issuerKeywordRecord: {},
+        label: 'vaultFactory',
       },
     }),
   );
 
-  const { creatorFacet: governorCreatorFacet, instance: governorInstance } =
-    await E(zoe).startInstance(
-      contractGovernorInstallation,
-      undefined,
-      governorTerms,
-      harden({
-        electorateCreatorFacet,
-        governed: {
-          feeMintAccess,
-          initialPoserInvitation,
-          initialShortfallInvitation,
-          marshaller,
-          storageNode,
-        },
-      }),
-    );
+  /** @type {GovernorStartedInstallationKit<typeof vaultFactoryInstallation>} */
+  const g = await E(consume.zoe).startInstance(
+    contractGovernorInstallation,
+    undefined,
+    governorTerms,
+    harden({
+      electorateCreatorFacet: consume.economicCommitteeCreatorFacet,
+      governed: vaultFactoryPrivateArgs,
+    }),
+    'vaultFactory.governor',
+  );
 
-  const [vaultFactoryInstance, vaultFactoryCreator] = await Promise.all([
-    E(governorCreatorFacet).getInstance(),
-    E(governorCreatorFacet).getCreatorFacet(),
-  ]);
+  const [vaultFactoryInstance, vaultFactoryCreator, publicFacet, adminFacet] =
+    await Promise.all([
+      E(g.creatorFacet).getInstance(),
+      E(g.creatorFacet).getCreatorFacet(),
+      E(g.creatorFacet).getPublicFacet(),
+      E(g.creatorFacet).getAdminFacet(),
+    ]);
 
-  const voteCreator = Far('vaultFactory vote creator', {
-    /** @type {VoteOnParamChanges} */
-    voteOnParamChanges: (...args) =>
-      E(governorCreatorFacet).voteOnParamChanges(...args),
-  });
+  // XXX omitting the governor
+  await E(consume.diagnostics).savePrivateArgs(
+    vaultFactoryInstance,
+    vaultFactoryPrivateArgs,
+  );
 
-  produce.vaultFactoryCreator.resolve(vaultFactoryCreator);
-  produce.vaultFactoryGovernorCreator.resolve(governorCreatorFacet);
-  produce.vaultFactoryVoteCreator.resolve(voteCreator);
+  vaultFactoryKit.resolve(
+    harden({
+      label: 'VaultFactory',
+      creatorFacet: vaultFactoryCreator,
+      adminFacet,
+      publicFacet,
+      instance: vaultFactoryInstance,
+
+      governor: g.instance,
+      governorAdminFacet: g.adminFacet,
+      governorCreatorFacet: g.creatorFacet,
+
+      // XXX try refactoring to use savePrivateArgs
+      privateArgs: vaultFactoryPrivateArgs,
+    }),
+  );
 
   // Advertise the installations, instances in agoricNames.
   instanceProduce.VaultFactory.resolve(vaultFactoryInstance);
-  instanceProduce.Treasury.resolve(vaultFactoryInstance);
-  instanceProduce.VaultFactoryGovernor.resolve(governorInstance);
+  instanceProduce.VaultFactoryGovernor.resolve(g.instance);
 };
 
 /**
@@ -481,7 +358,7 @@ export const startVaultFactory = async (
  * @param {string} [root0.options.vaultFactoryControllerAddress]
  */
 export const grantVaultFactoryControl = async (
-  { consume: { client, priceAuthorityAdmin, vaultFactoryCreator } },
+  { consume: { client, priceAuthorityAdmin, vaultFactoryKit } },
   { options: { vaultFactoryControllerAddress } = {} } = {},
 ) => {
   await E(client).assignBundle([
@@ -489,7 +366,7 @@ export const grantVaultFactoryControl = async (
       vaultFactoryCreatorFacet:
         typeof vaultFactoryControllerAddress === 'string' &&
         addr === vaultFactoryControllerAddress
-          ? vaultFactoryCreator
+          ? E.get(vaultFactoryKit).creatorFacet
           : undefined,
       priceAuthorityAdminFacet:
         typeof vaultFactoryControllerAddress === 'string' &&
@@ -501,92 +378,6 @@ export const grantVaultFactoryControl = async (
 };
 harden(grantVaultFactoryControl);
 
-/** @param {BootstrapPowers} powers */
-export const configureVaultFactoryUI = async ({
-  consume: { board, zoe },
-  issuer: {
-    consume: { [Stable.symbol]: stableIssuerP },
-  },
-  brand: {
-    consume: { [Stable.symbol]: stableBrandP },
-  },
-  installation: {
-    consume: {
-      amm: ammInstallation,
-      VaultFactory: vaultInstallation,
-      contractGovernor,
-      binaryVoteCounter,
-      liquidate,
-    },
-  },
-  instance: {
-    consume: { amm: ammInstance, VaultFactory: vaultInstance },
-  },
-  uiConfig,
-}) => {
-  const installs = await Collect.allValues({
-    vaultFactory: vaultInstallation,
-    amm: ammInstallation,
-    contractGovernor,
-    binaryVoteCounter,
-    liquidate,
-  });
-  const instances = await Collect.allValues({
-    amm: ammInstance,
-    vaultFactory: vaultInstance,
-  });
-  const [stableIssuer, stableBrand] = await Promise.all([
-    stableIssuerP,
-    stableBrandP,
-  ]);
-
-  const invitationIssuer = await E(zoe).getInvitationIssuer();
-
-  const vaultFactoryUiDefaults = {
-    CONTRACT_NAME: 'VaultFactory',
-    AMM_NAME: 'amm',
-    BRIDGE_URL: 'http://127.0.0.1:8000',
-    // Avoid setting API_URL, so that the UI uses the same origin it came from,
-    // if it has an api server.
-    // API_URL: 'http://127.0.0.1:8000',
-  };
-
-  // Look up all the board IDs.
-  const boardIdValue = [
-    ['INSTANCE_BOARD_ID', instances.vaultFactory],
-    ['INSTALLATION_BOARD_ID', installs.vaultFactory],
-    // @deprecated
-    ['RUN_ISSUER_BOARD_ID', stableIssuer],
-    // @deprecated
-    ['RUN_BRAND_BOARD_ID', stableBrand],
-    ['STABLE_ISSUER_BOARD_ID', stableIssuer],
-    ['STABLE_BRAND_BOARD_ID', stableBrand],
-    ['AMM_INSTALLATION_BOARD_ID', installs.amm],
-    ['LIQ_INSTALLATION_BOARD_ID', installs.liquidate],
-    ['BINARY_COUNTER_INSTALLATION_BOARD_ID', installs.binaryVoteCounter],
-    ['CONTRACT_GOVERNOR_INSTALLATION_BOARD_ID', installs.contractGovernor],
-    ['AMM_INSTANCE_BOARD_ID', instances.amm],
-    ['INVITE_BRAND_BOARD_ID', E(invitationIssuer).getBrand()],
-  ];
-  await Promise.all(
-    boardIdValue.map(async ([key, valP]) => {
-      const val = await valP;
-      const boardId = await E(board).getId(val);
-      vaultFactoryUiDefaults[key] = boardId;
-    }),
-  );
-
-  // Stash the defaults where the UI can find them.
-  harden(vaultFactoryUiDefaults);
-
-  // Install the names in agoricNames.
-  uiConfig.produce[vaultFactoryUiDefaults.CONTRACT_NAME].resolve(
-    vaultFactoryUiDefaults,
-  );
-  uiConfig.produce.Treasury.resolve(vaultFactoryUiDefaults); // compatibility
-};
-harden(configureVaultFactoryUI);
-
 /**
  * Start the reward distributor.
  *
@@ -596,17 +387,12 @@ export const startRewardDistributor = async ({
   consume: {
     chainTimerService,
     bankManager,
-    vaultFactoryCreator,
+    vaultFactoryKit,
     periodicFeeCollectors,
-    ammCreatorFacet,
-    stakeFactoryCreatorFacet,
-    reservePublicFacet,
+    reserveKit,
     zoe,
   },
-  produce: {
-    feeDistributorCreatorFacet: feeDistributorCreatorFacetP,
-    periodicFeeCollectors: periodicFeeCollectorsP,
-  },
+  produce: { feeDistributorKit, periodicFeeCollectors: periodicFeeCollectorsP },
   instance: {
     produce: { feeDistributor: feeDistributorP },
   },
@@ -627,7 +413,7 @@ export const startRewardDistributor = async ({
       timerService,
       collectionInterval: 60n * 60n, // 1 hour
       keywordShares: {
-        RewardDistributor: 1n,
+        RewardDistributor: 0n,
         Reserve: 1n,
       },
     }),
@@ -648,216 +434,186 @@ export const startRewardDistributor = async ({
       return undefined;
     });
 
-  const feeDistributorFacets = await E(zoe).startInstance(
+  /**
+   * @type {Awaited<
+   *   ReturnType<typeof import('../feeDistributor.js').makeFeeDistributor>>
+   *   & { adminFacet: AdminFacet, instance: Instance }
+   * }
+   */
+  const instanceKit = await E(zoe).startInstance(
     feeDistributor,
     { Fee: centralIssuer },
     feeDistributorTerms,
+    undefined,
+    'feeDistributor',
   );
-  await E(feeDistributorFacets.creatorFacet).setDestinations({
-    RewardDistributor:
-      rewardDistributorDepositFacet &&
-      E(feeDistributorFacets.creatorFacet).makeDepositFacetDestination(
-        rewardDistributorDepositFacet,
-      ),
-    Reserve: E(feeDistributorFacets.creatorFacet).makeOfferDestination(
+  /** @type {ERef<import('../feeDistributor.js').FeeDestination>} */
+  await E(instanceKit.creatorFacet).setDestinations({
+    ...(rewardDistributorDepositFacet && {
+      RewardDistributor: E(
+        instanceKit.creatorFacet,
+      ).makeDepositFacetDestination(rewardDistributorDepositFacet),
+    }),
+    Reserve: E(instanceKit.creatorFacet).makeOfferDestination(
+      zoe,
       'Collateral',
-      reservePublicFacet,
+      E.get(reserveKit).publicFacet,
       'makeAddCollateralInvitation',
     ),
   });
 
-  feeDistributorCreatorFacetP.resolve(feeDistributorFacets.creatorFacet);
-  feeDistributorP.resolve(feeDistributorFacets.instance);
+  feeDistributorKit.resolve(
+    harden({ ...instanceKit, label: 'feeDistributor' }),
+  );
+  feeDistributorP.resolve(instanceKit.instance);
 
   // Initialize the periodic collectors list if we don't have one.
-  periodicFeeCollectorsP.resolve([]);
+  periodicFeeCollectorsP.resolve(
+    makeScalarBigMapStore('periodicCollectors', { durable: true }),
+  );
   const periodicCollectors = await periodicFeeCollectors;
 
-  const collectorFacets = {
-    vaultFactory: vaultFactoryCreator,
-    amm: ammCreatorFacet,
-    runStake: stakeFactoryCreatorFacet,
+  const collectorKit = {
+    vaultFactory: E.get(vaultFactoryKit).creatorFacet,
   };
   await Promise.all(
-    Object.entries(collectorFacets).map(async ([debugName, collectorFacet]) => {
-      const collector = E(
-        feeDistributorFacets.creatorFacet,
-      ).makeContractFeeCollector(zoe, collectorFacet);
+    Object.entries(collectorKit).map(async ([debugName, collectorFacet]) => {
+      const collector = E(instanceKit.creatorFacet).makeContractFeeCollector(
+        zoe,
+        collectorFacet,
+      );
       const periodicCollector = await E(
-        feeDistributorFacets.creatorFacet,
+        instanceKit.creatorFacet,
       ).startPeriodicCollection(debugName, collector);
-      periodicCollectors.push(periodicCollector);
+      periodicCollectors.init(periodicCollectors.getSize(), periodicCollector);
     }),
   );
 };
 harden(startRewardDistributor);
 
 /**
- * @param {BootstrapPowers & PromiseSpaceOf<{
- *   lienBridge: StakingAuthority,
- * }>} powers
- */
-export const startLienBridge = async ({
-  consume: { bridgeManager: bridgeOptP },
-  produce: { lienBridge },
-  brand: {
-    consume: { [Stake.symbol]: bldP },
-  },
-}) => {
-  trace('lienBridge');
-
-  const bridgeManager = await bridgeOptP;
-  if (!bridgeManager) {
-    return;
-  }
-  const bldBrand = await bldP;
-  const reporter = makeStakeReporter(bridgeManager, bldBrand);
-  lienBridge.resolve(reporter);
-};
-
-/**
- * @typedef {EconomyBootstrapPowers & PromiseSpaceOf<{
- *   client: ClientManager,
- *   lienBridge: StakingAuthority,
- * }>} StakeFactoryBootstrapPowers
- */
-
-/**
- * @param {StakeFactoryBootstrapPowers } powers
+ * @param {EconomyBootstrapPowers} powers
  * @param {object} config
- * @param {bigint} [config.debtLimit] count of Minted
- * @param {Rational} [config.mintingRatio] ratio of Minted to BLD
- * @param {bigint} [config.interestRateBP]
- * @param {bigint} [config.loanFeeBP]
- * @param {bigint} [config.chargingPeriod]
- * @param {bigint} [config.recordingPeriod]
- * @typedef {[bigint, bigint]} Rational
- * @typedef {Awaited<ReturnType<typeof import('../stakeFactory/stakeFactory.js').start>>} StartStakeFactory
+ * @param {any} [config.auctionParams]
  */
-export const startStakeFactory = async (
+export const startAuctioneer = async (
   {
     consume: {
-      board,
       zoe,
-      feeMintAccess: feeMintAccessP,
-      lienBridge,
-      client,
+      board,
       chainTimerService,
+      priceAuthority,
       chainStorage,
-      economicCommitteeCreatorFacet,
+      economicCommitteeCreatorFacet: electorateCreatorFacet,
+    },
+    produce: { auctioneerKit },
+    instance: {
+      produce: { auctioneer: auctionInstance },
+      consume: { reserve: reserveInstance },
     },
-    // @ts-expect-error TODO: add to BootstrapPowers
-    produce: { stakeFactoryCreatorFacet, stakeFactoryGovernorCreatorFacet },
     installation: {
       consume: {
+        auctioneer: auctionInstallation,
         contractGovernor: contractGovernorInstallation,
-        stakeFactory: stakeFactoryInstallation,
       },
     },
-    instance: {
-      produce: { stakeFactory: stakeFactoryinstanceR },
-    },
-    brand: {
-      consume: { [Stake.symbol]: bldBrandP, [Stable.symbol]: runBrandP },
-      produce: { Attestation: attestationBrandR },
-    },
     issuer: {
-      consume: { [Stake.symbol]: bldIssuer },
-      produce: { Attestation: attestationIssuerR },
+      consume: { [Stable.symbol]: runIssuerP },
     },
   },
   {
-    debtLimit = 1_000_000_000_000n,
-    mintingRatio = [1n, 4n],
-    interestRateBP = 250n,
-    loanFeeBP = 200n,
-    chargingPeriod = SECONDS_PER_HOUR,
-    recordingPeriod = SECONDS_PER_DAY,
+    auctionParams = {
+      StartFrequency: 3600n,
+      ClockStep: 3n * 60n,
+      StartingRate: 10500n,
+      LowestRate: 6500n,
+      DiscountStep: 500n,
+      AuctionStartDelay: 2n,
+      PriceLockPeriod: 30n * 60n, // half an hour
+    },
   } = {},
 ) => {
-  const STORAGE_PATH = 'stakeFactory';
+  trace('startAuctioneer');
+  const STORAGE_PATH = 'auction';
 
-  const [bldBrand, runBrand] = await Promise.all([bldBrandP, runBrandP]);
+  const poserInvitationP = E(electorateCreatorFacet).getPoserInvitation();
 
-  const poserInvitationP = E(
-    economicCommitteeCreatorFacet,
-  ).getPoserInvitation();
-  const [initialPoserInvitation, electorateInvitationAmount, feeMintAccess] =
+  const [initialPoserInvitation, electorateInvitationAmount, runIssuer] =
     await Promise.all([
       poserInvitationP,
       E(E(zoe).getInvitationIssuer()).getAmountOf(poserInvitationP),
-      feeMintAccessP,
+      runIssuerP,
     ]);
 
-  const stakeFactoryTerms = makeStakeFactoryTerms(
-    {
-      timerService: chainTimerService,
-      chargingPeriod,
-      recordingPeriod,
-    },
-    {
-      debtLimit: AmountMath.make(runBrand, debtLimit),
-      mintingRatio: makeRatio(
-        mintingRatio[0],
-        runBrand,
-        mintingRatio[1],
-        bldBrand,
-      ),
-      interestRate: makeRatio(interestRateBP, runBrand, BASIS_POINTS),
-      loanFee: makeRatio(loanFeeBP, runBrand, BASIS_POINTS),
-      electorateInvitationAmount,
-    },
-  );
+  const timerBrand = await E(chainTimerService).getTimerBrand();
 
   const storageNode = await makeStorageNodeChild(chainStorage, STORAGE_PATH);
   const marshaller = await E(board).getReadonlyMarshaller();
 
-  const stakeTerms = await deeplyFulfilledObject(
+  const reservePublicFacet = await E(zoe).getPublicFacet(reserveInstance);
+
+  const auctionTerms = makeGovernedATerms(
+    { storageNode, marshaller },
+    chainTimerService,
+    priceAuthority,
+    reservePublicFacet,
+    {
+      ...auctionParams,
+      ElectorateInvitationAmount: electorateInvitationAmount,
+      TimerBrand: timerBrand,
+    },
+  );
+
+  const governorTerms = await deeplyFulfilledObject(
     harden({
       timer: chainTimerService,
-      governedContractInstallation: stakeFactoryInstallation,
+      governedContractInstallation: auctionInstallation,
       governed: {
-        terms: stakeFactoryTerms,
-        issuerKeywordRecord: { Stake: bldIssuer },
+        terms: auctionTerms,
+        issuerKeywordRecord: { Bid: runIssuer },
+        storageNode,
+        marshaller,
+        label: 'auctioneer',
       },
     }),
   );
 
-  /** @type {{ publicFacet: GovernorPublic, creatorFacet: GovernedContractFacetAccess<StakeFactoryPublic,StakeFactoryCreator>}} */
-  const governorFacets = await E(zoe).startInstance(
+  /** @type {GovernorStartedInstallationKit<typeof auctionInstallation>} */
+  const governorStartResult = await E(zoe).startInstance(
     contractGovernorInstallation,
-    {},
-    stakeTerms,
-    {
+    undefined,
+    governorTerms,
+    harden({
+      electorateCreatorFacet,
       governed: {
-        feeMintAccess,
         initialPoserInvitation,
-        lienBridge,
         storageNode,
         marshaller,
       },
-    },
+    }),
+    'auctioneer.governor',
   );
-  const governedInstance = await E(governorFacets.creatorFacet).getInstance();
-  const creatorFacet = E(governorFacets.creatorFacet).getCreatorFacet();
 
-  const {
-    issuers: { Attestation: attIssuer },
-    brands: { Attestation: attBrand },
-  } = await E(zoe).getTerms(governedInstance);
-
-  stakeFactoryCreatorFacet.resolve(creatorFacet);
-  stakeFactoryGovernorCreatorFacet.resolve(governorFacets.creatorFacet);
-  stakeFactoryinstanceR.resolve(governedInstance);
-  attestationBrandR.resolve(attBrand);
-  attestationIssuerR.resolve(attIssuer);
-  return Promise.all([
-    E(client).assignBundle([
-      address => ({
-        // @ts-expect-error ??? creatorFacet is a StakeFactoryCreator; it has the method
-        attMaker: E(creatorFacet).provideAttestationMaker(address),
-      }),
-    ]),
-  ]);
+  const [governedInstance, governedCreatorFacet, governedPublicFacet] =
+    await Promise.all([
+      E(governorStartResult.creatorFacet).getInstance(),
+      E(governorStartResult.creatorFacet).getCreatorFacet(),
+      E(governorStartResult.creatorFacet).getPublicFacet(),
+    ]);
+
+  auctioneerKit.resolve(
+    harden({
+      label: 'auctioneer',
+      creatorFacet: governedCreatorFacet,
+      adminFacet: governorStartResult.adminFacet,
+      publicFacet: governedPublicFacet,
+      instance: governedInstance,
+
+      governor: governorStartResult.instance,
+      governorCreatorFacet: governorStartResult.creatorFacet,
+      governorAdminFacet: governorStartResult.adminFacet,
+    }),
+  );
+
+  auctionInstance.resolve(governedInstance);
 };
-harden(startStakeFactory);