@agoric/inter-protocol 0.13.2-dev-65d3f14.0 → 0.13.2-pismo-dev-12e97f1.0

package/src/proposals/econ-behaviors.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import '../../exported.js';
 
 import { AmountMath } from '@agoric/ertp';
@@ -6,7 +8,7 @@ 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 } from '@endo/far';
+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';
@@ -20,7 +22,7 @@ import { makeAmmTerms } from '../vpool-xyk-amm/params.js';
 
 const trace = makeTracer('RunEconBehaviors', false);
 
-const { Fail } = assert;
+const { details: X } = assert;
 
 const SECONDS_PER_HOUR = 60n * 60n;
 const SECONDS_PER_DAY = 24n * SECONDS_PER_HOUR;
@@ -32,11 +34,10 @@ const MILLI = 1_000_000n;
  * @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 {object} PSMKit
+ * @typedef {object} PSMFacets
  * @property {Instance} psm
  * @property {Instance} psmGovernor
  * @property {Awaited<ReturnType<import('../psm/psm.js').start>>['creatorFacet']} psmCreatorFacet
@@ -48,47 +49,28 @@ const MILLI = 1_000_000n;
  * @typedef { WellKnownSpaces & ChainBootstrapSpace & EconomyBootstrapSpace
  * } EconomyBootstrapPowers
  * @typedef {PromiseSpaceOf<{
- *   ammKit: {
- *     instanceWithoutReserve: Instance,
- *     creatorFacet: XYKAMMCreatorFacet,
- *     governorCreatorFacet: GovernedContractFacetAccess<XYKAMMPublicFacet,XYKAMMCreatorFacet>,
- *     adminFacet: AdminFacet,
- *     publicFacet: XYKAMMPublicFacet,
- *   },
- *   economicCommitteeCreatorFacet: import('@agoric/governance/src/committee.js').CommitteeElectorateCreatorFacet,
- *   feeDistributorKit: {
- *     creatorFacet: import('../feeDistributor.js').FeeDistributorCreatorFacet,
- *     publicFacet: import('../feeDistributor.js').FeeDistributorPublicFacet,
- *     adminFacet: AdminFacet,
- *   },
+ *   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[],
- *   psmKit: MapStore<Brand, PSMKit>,
- *   econCharterKit: EconCharterStartResult,
- *   reserveKit: {
- *     publicFacet: import('../reserve/assetReserve.js').AssetReservePublicFacet,
- *     creatorFacet: import('../reserve/assetReserve.js').AssetReserveLimitedCreatorFacet,
- *     governorCreatorFacet: GovernedAssetReserveFacetAccess,
- *     adminFacet: AdminFacet,
- *   },
- *   stakeFactoryKit: {
- *     creatorFacet: StakeFactoryCreator,
- *     governorCreatorFacet: GovernedContractFacetAccess<{}, {}>,
- *     adminFacet: AdminFacet,
- *     publicFacet: StakeFactoryPublic,
- *   },
- *   vaultFactoryKit: {
- *     publicFacet: VaultFactoryPublicFacet,
- *     creatorFacet: VaultFactoryCreatorFacet,
- *     governorCreatorFacet: GovernedContractFacetAccess<{},{}>,
- *     adminFacet: AdminFacet,
- *   },
+ *   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,
  *   minInitialDebt: NatValue,
  * }>} EconomyBootstrapSpace
  */
 
-/** @typedef {import('@agoric/zoe/src/zoeService/utils.js').StartedInstanceKit<import('../econCommitteeCharter').start>} EconCharterStartResult */
-
 /**
  * @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.
@@ -167,7 +149,11 @@ export const setupAmm = async (
       economicCommitteeCreatorFacet: committeeCreator,
       chainStorage,
     },
-    produce: { ammKit },
+    produce: {
+      ammCreatorFacet,
+      ammInstanceWithoutReserve,
+      ammGovernorCreatorFacet,
+    },
     brand: {
       consume: { [Stable.symbol]: runBrandP },
     },
@@ -194,7 +180,7 @@ export const setupAmm = async (
 
   const ammTerms = makeAmmTerms(
     chainTimerService,
-    E(E(zoe).getInvitationIssuer()).getAmountOf(poserInvitation),
+    E(E(zoe).getInvitationIssuer()).getAmountOf(poserInvitationP),
     AmountMath.make(runBrand, minInitialPoolLiquidity),
   );
 
@@ -215,7 +201,7 @@ export const setupAmm = async (
     }),
   );
 
-  /** @type {{ creatorFacet: GovernedContractFacetAccess<XYKAMMPublicFacet,XYKAMMCreatorFacet>, publicFacet: GovernorPublic, instance: Instance, adminFacet: AdminFacet }} */
+  /** @type {{ creatorFacet: GovernedContractFacetAccess<XYKAMMPublicFacet,XYKAMMCreatorFacet>, publicFacet: GovernorPublic, instance: Instance }} */
   const g = await E(zoe).startInstance(
     governorInstallation,
     {},
@@ -235,19 +221,13 @@ export const setupAmm = async (
     E(g.creatorFacet).getPublicFacet(),
     E(g.publicFacet).getGovernedContract(),
   ]);
-  ammKit.resolve(
-    harden({
-      creatorFacet,
-      instanceWithoutReserve: instance,
-      governorCreatorFacet: g.creatorFacet,
-      adminFacet: g.adminFacet,
-      publicFacet: ammPublicFacet,
-    }),
-  );
+  ammGovernorCreatorFacet.resolve(g.creatorFacet);
+  ammCreatorFacet.resolve(creatorFacet);
 
   // Confirm that the amm was indeed setup
-  ammPublicFacet || Fail`ammPublicFacet broken  ${ammPublicFacet}`;
+  assert(ammPublicFacet, X`ammPublicFacet broken  ${ammPublicFacet}`);
 
+  ammInstanceWithoutReserve.resolve(instance);
   ammGovernor.resolve(g.instance);
   return ammInstallation;
 };
@@ -255,7 +235,8 @@ export const setupAmm = async (
 /** @param {EconomyBootstrapPowers} powers */
 export const setupReserve = async ({
   consume: {
-    ammKit: ammKitP,
+    ammCreatorFacet,
+    ammInstanceWithoutReserve,
     board,
     feeMintAccess: feeMintAccessP,
     chainStorage,
@@ -263,7 +244,11 @@ export const setupReserve = async ({
     zoe,
     economicCommitteeCreatorFacet: committeeCreator,
   },
-  produce: { reserveKit },
+  produce: {
+    reserveCreatorFacet,
+    reserveGovernorCreatorFacet,
+    reservePublicFacet,
+  },
   issuer: {
     consume: { [Stable.symbol]: centralIssuer },
   },
@@ -284,17 +269,16 @@ export const setupReserve = async ({
   const STORAGE_PATH = 'reserve';
   trace('setupReserve');
   const poserInvitationP = E(committeeCreator).getPoserInvitation();
-  const [poserInvitation, poserInvitationAmount, feeMintAccess, ammKit] =
+  const [poserInvitation, poserInvitationAmount, feeMintAccess] =
     await Promise.all([
       poserInvitationP,
       E(E(zoe).getInvitationIssuer()).getAmountOf(poserInvitationP),
       feeMintAccessP,
-      ammKitP,
     ]);
 
   const reserveTerms = makeReserveTerms(
     poserInvitationAmount,
-    ammKit.instanceWithoutReserve,
+    ammInstanceWithoutReserve,
   );
 
   const storageNode = await makeStorageNodeChild(chainStorage, STORAGE_PATH);
@@ -310,7 +294,7 @@ export const setupReserve = async ({
       },
     }),
   );
-  /** @type {{ creatorFacet: GovernedAssetReserveFacetAccess, publicFacet: GovernorPublic, instance: Instance, adminFacet: AdminFacet }} */
+  /** @type {{ creatorFacet: GovernedAssetReserveFacetAccess, publicFacet: GovernorPublic, instance: Instance }} */
   const g = await E(zoe).startInstance(
     governorInstallation,
     {},
@@ -332,14 +316,9 @@ export const setupReserve = async ({
     E(g.publicFacet).getGovernedContract(),
   ]);
 
-  reserveKit.resolve(
-    harden({
-      publicFacet,
-      creatorFacet,
-      governorCreatorFacet: g.creatorFacet,
-      adminFacet: g.adminFacet,
-    }),
-  );
+  reserveGovernorCreatorFacet.resolve(g.creatorFacet);
+  reserveCreatorFacet.resolve(creatorFacet);
+  reservePublicFacet.resolve(publicFacet);
 
   reserveInstanceProducer.resolve(instance);
   reserveGovernor.resolve(g.instance);
@@ -348,9 +327,9 @@ export const setupReserve = async ({
   // 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(ammKit.creatorFacet).resolveReserveFacet(publicFacet);
+  await E(ammCreatorFacet).resolveReserveFacet(publicFacet);
   // it now has the reserve
-  ammInstanceProducer.resolve(ammKit.instanceWithoutReserve);
+  ammInstanceProducer.resolve(ammInstanceWithoutReserve);
 
   return reserveInstallation;
 };
@@ -371,9 +350,9 @@ export const startVaultFactory = async (
       zoe,
       feeMintAccess: feeMintAccessP,
       economicCommitteeCreatorFacet: electorateCreatorFacet,
-      reserveKit,
+      reserveCreatorFacet,
     },
-    produce: { vaultFactoryKit },
+    produce, // {  vaultFactoryCreator }
     brand: {
       consume: { [Stable.symbol]: centralBrandP },
     },
@@ -401,9 +380,8 @@ export const startVaultFactory = async (
   trace('startVaultFactory');
 
   const poserInvitationP = E(electorateCreatorFacet).getPoserInvitation();
-  const shortfallInvitationP = E(
-    E.get(reserveKit).creatorFacet,
-  ).makeShortfallReportingInvitation();
+  const shortfallInvitationP =
+    E(reserveCreatorFacet).makeShortfallReportingInvitation();
   const [
     initialPoserInvitation,
     poserInvitationAmount,
@@ -455,41 +433,37 @@ export const startVaultFactory = async (
     }),
   );
 
-  const {
-    creatorFacet: governorCreatorFacet,
-    instance: governorInstance,
-    adminFacet,
-  } = await E(zoe).startInstance(
-    contractGovernorInstallation,
-    undefined,
-    governorTerms,
-    harden({
-      electorateCreatorFacet,
-      governed: {
-        feeMintAccess,
-        initialPoserInvitation,
-        initialShortfallInvitation,
-        marshaller,
-        storageNode,
-      },
-    }),
-  );
+  const { creatorFacet: governorCreatorFacet, instance: governorInstance } =
+    await E(zoe).startInstance(
+      contractGovernorInstallation,
+      undefined,
+      governorTerms,
+      harden({
+        electorateCreatorFacet,
+        governed: {
+          feeMintAccess,
+          initialPoserInvitation,
+          initialShortfallInvitation,
+          marshaller,
+          storageNode,
+        },
+      }),
+    );
 
-  const [vaultFactoryInstance, vaultFactoryCreator, publicFacet] =
-    await Promise.all([
-      E(governorCreatorFacet).getInstance(),
-      E(governorCreatorFacet).getCreatorFacet(),
-      E(governorCreatorFacet).getPublicFacet(),
-    ]);
+  const [vaultFactoryInstance, vaultFactoryCreator] = await Promise.all([
+    E(governorCreatorFacet).getInstance(),
+    E(governorCreatorFacet).getCreatorFacet(),
+  ]);
 
-  vaultFactoryKit.resolve(
-    harden({
-      creatorFacet: vaultFactoryCreator,
-      governorCreatorFacet,
-      adminFacet,
-      publicFacet,
-    }),
-  );
+  const voteCreator = Far('vaultFactory vote creator', {
+    /** @type {VoteOnParamChanges} */
+    voteOnParamChanges: (...args) =>
+      E(governorCreatorFacet).voteOnParamChanges(...args),
+  });
+
+  produce.vaultFactoryCreator.resolve(vaultFactoryCreator);
+  produce.vaultFactoryGovernorCreator.resolve(governorCreatorFacet);
+  produce.vaultFactoryVoteCreator.resolve(voteCreator);
 
   // Advertise the installations, instances in agoricNames.
   instanceProduce.VaultFactory.resolve(vaultFactoryInstance);
@@ -507,7 +481,7 @@ export const startVaultFactory = async (
  * @param {string} [root0.options.vaultFactoryControllerAddress]
  */
 export const grantVaultFactoryControl = async (
-  { consume: { client, priceAuthorityAdmin, vaultFactoryKit } },
+  { consume: { client, priceAuthorityAdmin, vaultFactoryCreator } },
   { options: { vaultFactoryControllerAddress } = {} } = {},
 ) => {
   await E(client).assignBundle([
@@ -515,7 +489,7 @@ export const grantVaultFactoryControl = async (
       vaultFactoryCreatorFacet:
         typeof vaultFactoryControllerAddress === 'string' &&
         addr === vaultFactoryControllerAddress
-          ? E.get(vaultFactoryKit).creatorFacet
+          ? vaultFactoryCreator
           : undefined,
       priceAuthorityAdminFacet:
         typeof vaultFactoryControllerAddress === 'string' &&
@@ -622,14 +596,17 @@ export const startRewardDistributor = async ({
   consume: {
     chainTimerService,
     bankManager,
-    vaultFactoryKit,
+    vaultFactoryCreator,
     periodicFeeCollectors,
-    ammKit,
-    stakeFactoryKit,
-    reserveKit,
+    ammCreatorFacet,
+    stakeFactoryCreatorFacet,
+    reservePublicFacet,
     zoe,
   },
-  produce: { feeDistributorKit, periodicFeeCollectors: periodicFeeCollectorsP },
+  produce: {
+    feeDistributorCreatorFacet: feeDistributorCreatorFacetP,
+    periodicFeeCollectors: periodicFeeCollectorsP,
+  },
   instance: {
     produce: { feeDistributor: feeDistributorP },
   },
@@ -671,50 +648,43 @@ export const startRewardDistributor = async ({
       return undefined;
     });
 
-  const instanceKit = await E(zoe).startInstance(
+  const feeDistributorFacets = await E(zoe).startInstance(
     feeDistributor,
     { Fee: centralIssuer },
     feeDistributorTerms,
   );
-  await E(instanceKit.creatorFacet).setDestinations({
+  await E(feeDistributorFacets.creatorFacet).setDestinations({
     RewardDistributor:
       rewardDistributorDepositFacet &&
-      E(instanceKit.creatorFacet).makeDepositFacetDestination(
+      E(feeDistributorFacets.creatorFacet).makeDepositFacetDestination(
         rewardDistributorDepositFacet,
       ),
-    Reserve: E(instanceKit.creatorFacet).makeOfferDestination(
+    Reserve: E(feeDistributorFacets.creatorFacet).makeOfferDestination(
       'Collateral',
-      E.get(reserveKit).publicFacet,
+      reservePublicFacet,
       'makeAddCollateralInvitation',
     ),
   });
 
-  feeDistributorKit.resolve(
-    harden({
-      creatorFacet: instanceKit.creatorFacet,
-      publicFacet: instanceKit.publicFacet,
-      adminFacet: instanceKit.adminFacet,
-    }),
-  );
-  feeDistributorP.resolve(instanceKit.instance);
+  feeDistributorCreatorFacetP.resolve(feeDistributorFacets.creatorFacet);
+  feeDistributorP.resolve(feeDistributorFacets.instance);
 
   // Initialize the periodic collectors list if we don't have one.
   periodicFeeCollectorsP.resolve([]);
   const periodicCollectors = await periodicFeeCollectors;
 
-  const collectorKit = {
-    vaultFactory: E.get(vaultFactoryKit).creatorFacet,
-    amm: E.get(ammKit).creatorFacet,
-    runStake: E.get(stakeFactoryKit).creatorFacet,
+  const collectorFacets = {
+    vaultFactory: vaultFactoryCreator,
+    amm: ammCreatorFacet,
+    runStake: stakeFactoryCreatorFacet,
   };
   await Promise.all(
-    Object.entries(collectorKit).map(async ([debugName, collectorFacet]) => {
-      const collector = E(instanceKit.creatorFacet).makeContractFeeCollector(
-        zoe,
-        collectorFacet,
-      );
+    Object.entries(collectorFacets).map(async ([debugName, collectorFacet]) => {
+      const collector = E(
+        feeDistributorFacets.creatorFacet,
+      ).makeContractFeeCollector(zoe, collectorFacet);
       const periodicCollector = await E(
-        instanceKit.creatorFacet,
+        feeDistributorFacets.creatorFacet,
       ).startPeriodicCollection(debugName, collector);
       periodicCollectors.push(periodicCollector);
     }),
@@ -776,7 +746,8 @@ export const startStakeFactory = async (
       chainStorage,
       economicCommitteeCreatorFacet,
     },
-    produce: { stakeFactoryKit },
+    // @ts-expect-error TODO: add to BootstrapPowers
+    produce: { stakeFactoryCreatorFacet, stakeFactoryGovernorCreatorFacet },
     installation: {
       consume: {
         contractGovernor: contractGovernorInstallation,
@@ -852,8 +823,8 @@ export const startStakeFactory = async (
     }),
   );
 
-  /** @type {{ publicFacet: GovernorPublic, creatorFacet: GovernedContractFacetAccess<StakeFactoryPublic,StakeFactoryCreator>, adminFacet: AdminFacet}} */
-  const governorStartResult = await E(zoe).startInstance(
+  /** @type {{ publicFacet: GovernorPublic, creatorFacet: GovernedContractFacetAccess<StakeFactoryPublic,StakeFactoryCreator>}} */
+  const governorFacets = await E(zoe).startInstance(
     contractGovernorInstallation,
     {},
     stakeTerms,
@@ -867,28 +838,16 @@ export const startStakeFactory = async (
       },
     },
   );
-
-  const [governedInstance, governedCreatorFacet, governedPublicFacet] =
-    await Promise.all([
-      E(governorStartResult.creatorFacet).getInstance(),
-      E(governorStartResult.creatorFacet).getCreatorFacet(),
-      E(governorStartResult.creatorFacet).getPublicFacet(),
-    ]);
+  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);
 
-  stakeFactoryKit.resolve(
-    harden({
-      creatorFacet: governedCreatorFacet,
-      governorCreatorFacet: governorStartResult.creatorFacet,
-      adminFacet: governorStartResult.adminFacet,
-      publicFacet: governedPublicFacet,
-    }),
-  );
-
+  stakeFactoryCreatorFacet.resolve(creatorFacet);
+  stakeFactoryGovernorCreatorFacet.resolve(governorFacets.creatorFacet);
   stakeFactoryinstanceR.resolve(governedInstance);
   attestationBrandR.resolve(attBrand);
   attestationIssuerR.resolve(attIssuer);
@@ -896,7 +855,7 @@ export const startStakeFactory = async (
     E(client).assignBundle([
       address => ({
         // @ts-expect-error ??? creatorFacet is a StakeFactoryCreator; it has the method
-        attMaker: E(governedCreatorFacet).provideAttestationMaker(address),
+        attMaker: E(creatorFacet).provideAttestationMaker(address),
       }),
     ]),
   ]);

package/src/proposals/price-feed-proposal.js

@@ -1,4 +1,3 @@
-// @ts-nocheck -- lots of type errors. low prio b/c proposals are like scripts
 import { E } from '@endo/far';
 import { makeIssuerKit } from '@agoric/ertp';
 import {
@@ -9,35 +8,14 @@ import { deeplyFulfilledObject } from '@agoric/internal';
 
 import { unitAmount } from '@agoric/zoe/src/contractSupport/priceQuote.js';
 import { reserveThenDeposit, reserveThenGetNames } from './utils.js';
-import { makeTracer } from '../makeTracer.js';
 
-const trace = makeTracer('RunPriceFeed');
-
-/** @type {(name: string) => string} */
+/** @type {(name: string) => void} */
 const sanitizePathSegment = name => {
   const candidate = name.replace(/ /g, '_');
   assertPathSegment(candidate);
   return candidate;
 };
 
-/**
- * @typedef {{
- * brandIn?: ERef<Brand<'nat'> | undefined>,
- * brandOut?: ERef<Brand<'nat'> | undefined>,
- * IN_BRAND_NAME: string,
- * IN_BRAND_DECIMALS: string,
- * OUT_BRAND_NAME: string,
- * OUT_BRAND_DECIMALS: string,
- * }} PriceFeedOptions
- */
-
-/**
- * Create inert brands (no mint or issuer) referred to by price oracles.
- *
- * @param {ChainBootstrapSpace} space
- * @param {{options: {priceFeedOptions: PriceFeedOptions}}} opt
- * @returns {Promise<[Brand<'nat'>, Brand<'nat'>]>}
- */
 export const ensureOracleBrands = async (
   { consume: { agoricNamesAdmin } },
   {
@@ -53,11 +31,9 @@ export const ensureOracleBrands = async (
     },
   },
 ) => {
-  trace('ensureOracleBrands');
-  /** @type {Promise<import('@agoric/vats').NameAdmin>} */
+  /** @type {NameAdmin} */
   const obAdmin = E(agoricNamesAdmin).lookupAdmin('oracleBrand');
 
-  /** @type {(brand: ERef<Brand<'nat'> | undefined>, name: string, decimals: string) => Promise<Brand<'nat'>>} */
   const updateFreshBrand = async (brand, name, decimals) => {
     const b = await brand;
     if (b) {
@@ -87,7 +63,7 @@ export const ensureOracleBrands = async (
 
 /**
  * @param {ChainBootstrapSpace} powers
- * @param {{options: {priceFeedOptions: {AGORIC_INSTANCE_NAME: string, oracleAddresses: string[], contractTerms: unknown, IN_BRAND_NAME: string, OUT_BRAND_NAME: string}}}} config
+ * @param {{options: {priceFeedOptions: {AGORIC_INSTANCE_NAME: string, oracleAddresses: UNKNOWN, contractTerms: unknown, IN_BRAND_NAME: string, OUT_BRAND_NAME: string}}}} config
  */
 export const createPriceFeed = async (
   {
@@ -117,7 +93,6 @@ export const createPriceFeed = async (
     },
   },
 ) => {
-  trace('createPriceFeed');
   const STORAGE_PATH = 'priceFeed';
 
   // Default to an empty Map and home.priceAuthority.
@@ -129,7 +104,7 @@ export const createPriceFeed = async (
   /**
    * Values come from economy-template.json, which at this writing had IN:ATOM, OUT:USD
    *
-   * @type {[[Brand<'nat'>, Brand<'nat'>], [Installation<import('@agoric/zoe/src/contracts/priceAggregator.js').start>]]}
+   * @type {[[Brand, Brand], [Installation<import('@agoric/zoe/src/contracts/priceAggregator.js').start>]]}
    */
   const [[brandIn, brandOut], [priceAggregator]] = await Promise.all([
     reserveThenGetNames(E(agoricNamesAdmin).lookupAdmin('oracleBrand'), [
@@ -153,6 +128,7 @@ export const createPriceFeed = async (
       unitAmountIn,
     }),
   );
+  terms.absent;
 
   const storageNode = await makeStorageNodeChild(chainStorage, STORAGE_PATH);
   const marshaller = E(board).getReadonlyMarshaller();
@@ -204,19 +180,11 @@ export const createPriceFeed = async (
     );
   };
 
-  trace('distributing invitations', oracleAddresses);
   await Promise.all(oracleAddresses.map(distributeInvitation));
-  trace('createPriceFeed complete');
 };
 
+// Return the manifest, installations, and options.
 const t = 'priceFeed';
-/**
- * Add a price feed to a running chain, returning the manifest, installations, and options.
- *
- * @param {object} utils
- * @param {(ref: unknown) => Promise<unknown>} [utils.restoreRef]
- * @param {PriceFeedOptions} priceFeedOptions
- */
 export const getManifestForPriceFeed = async (
   { restoreRef },
   priceFeedOptions,
@@ -257,83 +225,3 @@ export const getManifestForPriceFeed = async (
     },
   },
 });
-
-/**
- * @param {import('./econ-behaviors').EconomyBootstrapPowers} powers
- * @param {object} [config]
- * @param {object} [config.options]
- * @param {string[]} [config.options.demoOracleAddresses]
- */
-export const startPriceFeeds = async (
-  {
-    consume,
-    produce,
-    installation: {
-      consume: { priceAggregator },
-    },
-  },
-  { options: { demoOracleAddresses = [] } = {} },
-) => {
-  trace('startPriceFeeds');
-
-  // eventually this will have be parameterized. for now we just need one contract
-  // working well enough to build tooling around.
-  const inBrandName = 'ATOM';
-  const outBrandName = 'USD';
-
-  /** @type {ERef<NameAdmin>} */
-  const installAdmin = E(consume.agoricNamesAdmin).lookupAdmin('installation');
-  await E(installAdmin).update('priceAggregator', priceAggregator);
-
-  await ensureOracleBrands(
-    { consume },
-    {
-      options: {
-        priceFeedOptions: {
-          IN_BRAND_NAME: inBrandName,
-          IN_BRAND_DECIMALS: '6',
-          OUT_BRAND_NAME: outBrandName,
-          OUT_BRAND_DECIMALS: '6',
-        },
-      },
-    },
-  );
-
-  await createPriceFeed(
-    { consume, produce },
-    {
-      options: {
-        priceFeedOptions: {
-          AGORIC_INSTANCE_NAME: `${inBrandName}-${outBrandName} price feed`,
-          contractTerms: {
-            POLL_INTERVAL: 1n,
-          },
-          oracleAddresses: demoOracleAddresses,
-          IN_BRAND_NAME: inBrandName,
-          OUT_BRAND_NAME: outBrandName,
-        },
-      },
-    },
-  );
-  trace('startPriceFeeds complete');
-};
-harden(startPriceFeeds);
-
-export const PRICE_FEEDS_MANIFEST = harden({
-  [startPriceFeeds.name]: {
-    consume: {
-      agoricNamesAdmin: true,
-      aggregators: true,
-      board: true,
-      chainStorage: true,
-      chainTimerService: true,
-      client: true,
-      namesByAddressAdmin: true,
-      priceAuthority: true,
-      priceAuthorityAdmin: true,
-      zoe: true,
-    },
-    produce: { aggregators: true },
-    installation: { consume: { priceAggregator: true } },
-  },
-});