@agoric/inter-protocol 0.16.2-other-dev-1f26562.0 → 0.16.2-other-dev-3eb1a1d.0

package/src/proposals/econ-behaviors.js

@@ -1,20 +1,17 @@
 // @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 { Stable } from '@agoric/vats/src/tokens.js';
 import { E } from '@endo/far';
 import { makeScalarBigMapStore } from '@agoric/vat-data';
+import { Stable } from '@agoric/internal/src/tokens.js';
 import { makeGovernedTerms as makeGovernedATerms } from '../auction/params.js';
 import { makeReserveTerms } from '../reserve/params.js';
 import { makeGovernedTerms as makeGovernedVFTerms } from '../vaultFactory/params.js';
 
+/** @import {StartedInstanceKit} from '@agoric/zoe/src/zoeService/utils.js' */
+
 const trace = makeTracer('RunEconBehaviors', true);
 
 export const SECONDS_PER_MINUTE = 60n;
@@ -22,54 +19,73 @@ 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 {import('../vaultFactory/vaultFactory.js').VaultFactoryContract['publicFacet']} VaultFactoryPublicFacet
- * @typedef {import('../auction/auctioneer.js').AuctioneerPublicFacet} AuctioneerPublicFacet
- * @typedef {import('../auction/auctioneer.js').AuctioneerCreatorFacet} AuctioneerCreatorFacet
- */
+/** @import {start as VFStart} from '../vaultFactory/vaultFactory.js' */
+/** @typedef {Awaited<ReturnType<VFStart>>['publicFacet']} VaultFactoryPublicFacet */
 
 /**
  * @typedef {object} PSMKit
  * @property {string} label
  * @property {Instance} psm
  * @property {Instance} psmGovernor
- * @property {Awaited<ReturnType<Awaited<ReturnType<import('../psm/psm.js')['prepare']>>['creatorFacet']['getLimitedCreatorFacet']>>} psmCreatorFacet
- * @property {GovernorCreatorFacet<import('../../src/psm/psm.js')['prepare']>} psmGovernorCreatorFacet
+ * @property {Awaited<
+ *   ReturnType<
+ *     Awaited<
+ *       ReturnType<import('../psm/psm.js')['start']>
+ *     >['creatorFacet']['getLimitedCreatorFacet']
+ *   >
+ * >} psmCreatorFacet
+ * @property {GovernorCreatorFacet<import('../../src/psm/psm.js')['start']>} psmGovernorCreatorFacet
  * @property {AdminFacet} psmAdminFacet
  */
 
-/**
- * @typedef {GovernanceFacetKit<import('../auction/auctioneer.js').start>} AuctioneerKit
- */
+/** @typedef {GovernanceFacetKit<import('../auction/auctioneer.js').start>} AuctioneerKit */
 
 /**
- * @typedef { WellKnownSpaces & ChainBootstrapSpace & EconomyBootstrapSpace
- * } EconomyBootstrapPowers
+ * @typedef {WellKnownSpaces & ChainBootstrapSpace & EconomyBootstrapSpace} EconomyBootstrapPowers
+ *
+ *
  * @typedef {PromiseSpaceOf<{
- *   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,
+ *   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')['start']
+ *   >;
+ *   vaultFactoryKit: GovernanceFacetKit<VFStart>;
+ *   auctioneerKit: AuctioneerKit;
+ *   newAuctioneerKit: AuctioneerKit | undefined;
+ *   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 */
+/**
+ * @typedef {StartedInstanceKit<
+ *   import('../econCommitteeCharter.js')['start']
+ * >} EconCharterStartResult
+ */
+/**
+ * @typedef {StartedInstanceKit<
+ *   import('@agoric/governance/src/committee.js')['start']
+ * >} 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.
+ *   Each function is passed a set of powers for reading from and writing to the
+ *   vat config.
  *
- * Each of the things they produce they're responsible for resolving or setting.
+ *   Each of the things they produce they're responsible for resolving or setting.
  *
- * In production called by @agoric/vats to bootstrap.
+ *   In production called by @agoric/vats to bootstrap.
  */
 
 /** @param {EconomyBootstrapPowers} powers */
@@ -214,14 +230,14 @@ export const setupVaultFactoryArguments = async (
     initialShortfallInvitation,
     shortfallInvitationAmount,
     feeMintAccess,
-    auctioneerPublicFacet,
+    auctioneerInstance,
   ] = await Promise.all([
     poserInvitationP,
     E(E(zoe).getInvitationIssuer()).getAmountOf(poserInvitationP),
     shortfallInvitationP,
     E(E(zoe).getInvitationIssuer()).getAmountOf(shortfallInvitationP),
     feeMintAccessP,
-    E.get(auctioneerKit).publicFacet,
+    E.get(auctioneerKit).instance,
   ]);
 
   const reservePublicFacet = await E.get(reserveKit).publicFacet;
@@ -230,7 +246,6 @@ export const setupVaultFactoryArguments = async (
 
   const vaultFactoryTerms = makeGovernedVFTerms({
     priceAuthority,
-    auctioneerPublicFacet,
     reservePublicFacet,
     interestTiming,
     timer: chainTimerService,
@@ -242,6 +257,7 @@ export const setupVaultFactoryArguments = async (
   });
 
   const vaultFactoryPrivateArgs = {
+    auctioneerInstance,
     feeMintAccess,
     initialPoserInvitation,
     initialShortfallInvitation,
@@ -301,7 +317,11 @@ export const startVaultFactory = async (
     }),
   );
 
-  /** @type {GovernorStartedInstallationKit<typeof vaultFactoryInstallation>} */
+  /**
+   * @type {GovernorStartedInstallationKit<
+   *   typeof vaultFactoryInstallation
+   * >}
+   */
   const g = await E(consume.zoe).startInstance(
     contractGovernorInstallation,
     undefined,
@@ -350,8 +370,8 @@ export const startVaultFactory = async (
 };
 
 /**
- * Grant access to the VaultFactory creatorFacet
- * to up to one user based on address.
+ * Grant access to the VaultFactory creatorFacet to up to one user based on
+ * address.
  *
  * @param {EconomyBootstrapPowers} powers
  * @param {object} [root0]
@@ -436,19 +456,18 @@ export const startRewardDistributor = async ({
     });
 
   /**
-   * @type {Awaited<
-   *   ReturnType<typeof import('../feeDistributor.js').makeFeeDistributor>>
-   *   & { adminFacet: AdminFacet, instance: Instance }
-   * }
+   * @type {StartedInstanceKit<
+   *   typeof import('@agoric/inter-protocol/src/feeDistributor.js').start
+   * >}
    */
   const instanceKit = await E(zoe).startInstance(
     feeDistributor,
     { Fee: centralIssuer },
+    // @ts-expect-error XXX
     feeDistributorTerms,
     undefined,
     'feeDistributor',
   );
-  /** @type {ERef<import('../feeDistributor.js').FeeDestination>} */
   await E(instanceKit.creatorFacet).setDestinations({
     ...(rewardDistributorDepositFacet && {
       RewardDistributor: E(

package/src/proposals/price-feed-proposal.d.ts

@@ -0,0 +1,84 @@
+export { oracleBrandFeedName as instanceNameFor };
+export function ensureOracleBrands({ namedVat: { consume: { agoricNames }, }, oracleBrand: { produce: oracleBrandProduce }, }: ChainBootstrapSpace & NamedVatPowers, { options: { priceFeedOptions: { brandIn: rawBrandIn, brandOut: rawBrandOut, IN_BRAND_NAME, IN_BRAND_DECIMALS, OUT_BRAND_NAME, OUT_BRAND_DECIMALS, }, }, }: {
+    options: {
+        priceFeedOptions: PriceFeedOptions;
+    };
+}): Promise<[Brand<"nat">, Brand<"nat">]>;
+export function createPriceFeed({ consume: { agoricNamesAdmin, board, chainStorage, chainTimerService, client, econCharterKit, highPrioritySendersManager, namesByAddressAdmin, priceAuthority, priceAuthorityAdmin, startGovernedUpgradable, zoe, }, instance: { produce: produceInstance }, }: ChainBootstrapSpace, { options: { priceFeedOptions: { AGORIC_INSTANCE_NAME, oracleAddresses, contractTerms, IN_BRAND_NAME, OUT_BRAND_NAME, priceAggregatorRef, }, }, }: {
+    options: {
+        priceFeedOptions: {
+            AGORIC_INSTANCE_NAME: string;
+            oracleAddresses: string[];
+            contractTerms: import("@agoric/inter-protocol/src/price/fluxAggregatorKit.js").ChainlinkConfig;
+            IN_BRAND_NAME: string;
+            OUT_BRAND_NAME: string;
+            priceAggregatorRef: Installation;
+        };
+    };
+}): Promise<void>;
+export function getManifestForPriceFeed({ restoreRef }: {
+    restoreRef?: ((ref: unknown) => Promise<unknown>) | undefined;
+}, priceFeedOptions: PriceFeedOptions): Promise<{
+    manifest: {
+        [x: string]: {
+            consume: {
+                agoricNamesAdmin: string;
+                board: string;
+                chainStorage: string;
+                chainTimerService: string;
+                client: string;
+                econCharterKit: string;
+                highPrioritySendersManager: string;
+                namesByAddressAdmin: string;
+                priceAuthority: string;
+                priceAuthorityAdmin: string;
+                startGovernedUpgradable: string;
+                zoe: string;
+            };
+            instance: {
+                produce: string;
+            };
+            namedVat?: undefined;
+            oracleBrand?: undefined;
+        } | {
+            namedVat: {
+                consume: {
+                    agoricNames: string;
+                };
+            };
+            oracleBrand: {
+                produce: string;
+            };
+            consume?: undefined;
+            instance?: undefined;
+        };
+    };
+    installations: {
+        priceAggregator: Promise<unknown>;
+    };
+    options: {
+        priceFeedOptions: {
+            brandIn: any;
+            brandOut: any;
+            IN_BRAND_NAME: string;
+            IN_BRAND_DECIMALS: string;
+            OUT_BRAND_NAME: string;
+            OUT_BRAND_DECIMALS: string;
+        };
+    };
+}>;
+export function startPriceFeeds({ consume, produce, installation: { consume: { priceAggregator }, }, }: import("./econ-behaviors.js").EconomyBootstrapPowers, { options: { demoOracleAddresses } }?: {
+    options?: {
+        demoOracleAddresses?: string[] | undefined;
+    } | undefined;
+} | undefined): Promise<void>;
+export type PriceFeedOptions = {
+    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;
+};
+import { oracleBrandFeedName } from './utils.js';
+//# sourceMappingURL=price-feed-proposal.d.ts.map

package/src/proposals/price-feed-proposal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"price-feed-proposal.d.ts","sourceRoot":"","sources":["price-feed-proposal.js"],"names":[],"mappings":";AA6CO,+HAJI,mBAAmB,GAAG,cAAc,8JACpC;IAAE,OAAO,EAAE;QAAE,gBAAgB,EAAE,gBAAgB,CAAA;KAAE,CAAA;CAAE,GACjD,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAsCjD;AAiBM,iSAdI,mBAAmB,qJACnB;IACN,OAAO,EAAE;QACP,gBAAgB,EAAE;YAChB,oBAAoB,EAAE,MAAM,CAAC;YAC7B,eAAe,EAAE,MAAM,EAAE,CAAC;YAC1B,aAAa,EAAE,OAAO,uDAAuD,EAAE,eAAe,CAAC;YAC/F,aAAa,EAAE,MAAM,CAAC;YACtB,cAAc,EAAE,MAAM,CAAC;YACvB,kBAAkB,EAAE,YAAY,CAAC;SAClC,CAAC;KACH,CAAC;CACH,iBAiKH;AAWM,wDAHJ;IAAmD,UAAU,UAA/C,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC;CAC1C,oBAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA3OP,MAAM;+BACF,MAAM;4BACT,MAAM;gCACF,MAAM;;;GAyR7B;AAQK,wGALI,OAAO,qBAAqB,EAAE,sBAAsB;;;;8BA8D9D;+BAhWY;IACR,OAAO,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC;IACzC,QAAQ,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;CAC5B;oCAtBG,YAAY"}

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

@@ -1,13 +1,20 @@
 // @ts-nocheck -- lots of type errors. low prio b/c proposals are like scripts
-import { E } from '@endo/far';
+import { makeTracer } from '@agoric/internal';
 import {
-  makeStorageNodeChild,
   assertPathSegment,
+  makeStorageNodeChild,
 } from '@agoric/internal/src/lib-chainStorage.js';
-import { makeTracer } from '@agoric/internal';
+import { E } from '@endo/far';
 
 import { unitAmount } from '@agoric/zoe/src/contractSupport/priceQuote.js';
-import { reserveThenDeposit, reserveThenGetNames } from './utils.js';
+import {
+  oracleBrandFeedName,
+  reserveThenDeposit,
+  reserveThenGetNames,
+} from './utils.js';
+
+// backwards compatibility
+export { oracleBrandFeedName as instanceNameFor };
 
 const trace = makeTracer('RunPriceFeed', true);
 
@@ -20,12 +27,12 @@ const sanitizePathSegment = name => {
 
 /**
  * @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,
+ *   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
  */
 
@@ -33,7 +40,7 @@ const sanitizePathSegment = name => {
  * Create inert brands (no mint or issuer) referred to by price oracles.
  *
  * @param {ChainBootstrapSpace & NamedVatPowers} space
- * @param {{options: {priceFeedOptions: PriceFeedOptions}}} opt
+ * @param {{ options: { priceFeedOptions: PriceFeedOptions } }} opt
  * @returns {Promise<[Brand<'nat'>, Brand<'nat'>]>}
  */
 export const ensureOracleBrands = async (
@@ -56,13 +63,10 @@ export const ensureOracleBrands = async (
     },
   },
 ) => {
-  trace('ensureOracleBrands');
-
   const updateFreshBrand = async (brand, name, decimals) => {
     let b = await brand;
     if (!b) {
       // not 1st await
-      // eslint-disable-next-line @jessie.js/no-nested-await
       b = await E(agoricNames).provideInertBrand(
         name,
         harden({ decimalPlaces: parseInt(decimals, 10) }),
@@ -79,7 +83,18 @@ export const ensureOracleBrands = async (
 
 /**
  * @param {ChainBootstrapSpace} powers
- * @param {{options: {priceFeedOptions: {AGORIC_INSTANCE_NAME: string, oracleAddresses: string[], contractTerms: import('@agoric/inter-protocol/src/price/fluxAggregatorKit.js').ChainlinkConfig, IN_BRAND_NAME: string, OUT_BRAND_NAME: string}}}} config
+ * @param {{
+ *   options: {
+ *     priceFeedOptions: {
+ *       AGORIC_INSTANCE_NAME: string;
+ *       oracleAddresses: string[];
+ *       contractTerms: import('@agoric/inter-protocol/src/price/fluxAggregatorKit.js').ChainlinkConfig;
+ *       IN_BRAND_NAME: string;
+ *       OUT_BRAND_NAME: string;
+ *       priceAggregatorRef: Installation;
+ *     };
+ *   };
+ * }} config
  */
 export const createPriceFeed = async (
   {
@@ -95,7 +110,9 @@ export const createPriceFeed = async (
       priceAuthority,
       priceAuthorityAdmin,
       startGovernedUpgradable,
+      zoe,
     },
+    instance: { produce: produceInstance },
   },
   {
     options: {
@@ -105,30 +122,62 @@ export const createPriceFeed = async (
         contractTerms,
         IN_BRAND_NAME,
         OUT_BRAND_NAME,
+        priceAggregatorRef,
       },
     },
   },
 ) => {
-  trace('createPriceFeed');
+  trace('createPriceFeed', AGORIC_INSTANCE_NAME);
   const STORAGE_PATH = 'priceFeed';
 
   void E(client).assignBundle([_addr => ({ priceAuthority })]);
 
-  const timer = await chainTimerService;
+  let installationP;
+  await null;
+  if (priceAggregatorRef) {
+    const bundleID = await E.get(priceAggregatorRef).bundleID;
+    if (bundleID) {
+      installationP = E(zoe).installBundleID(bundleID);
+      await E.when(
+        installationP,
+        installation =>
+          E(E(agoricNamesAdmin).lookupAdmin('installation')).update(
+            'priceAggregator',
+            installation,
+          ),
+        err =>
+          console.error(
+            `🚨 failed to update priceAggregator installation for ${AGORIC_INSTANCE_NAME}`,
+            err,
+          ),
+      );
+    }
+  }
+  if (!installationP) {
+    installationP = E.get(
+      reserveThenGetNames(E(agoricNamesAdmin).lookupAdmin('installation'), [
+        'priceAggregator',
+      ]),
+    )[0];
+    console.error(
+      '🚨 failed to install new fluxAggregator bundle, reusing previous one.',
+    );
+  }
 
   /**
-   * Values come from economy-template.json, which at this writing had IN:ATOM, OUT:USD
-   *
-   * @type {[[Brand<'nat'>, Brand<'nat'>], [Installation<import('@agoric/inter-protocol/src/price/fluxAggregatorContract.js').prepare>]]}
+   * @type {[
+   *   [Brand<'nat'>, Brand<'nat'>],
+   *   Installation<import('@agoric/inter-protocol/src/price/fluxAggregatorContract.js')['start]>,
+   *   Timer,
+   * ]}
    */
-  const [[brandIn, brandOut], [priceAggregator]] = await Promise.all([
+  const [[brandIn, brandOut], installation, timer] = await Promise.all([
     reserveThenGetNames(E(agoricNamesAdmin).lookupAdmin('oracleBrand'), [
       IN_BRAND_NAME,
       OUT_BRAND_NAME,
     ]),
-    reserveThenGetNames(E(agoricNamesAdmin).lookupAdmin('installation'), [
-      'priceAggregator',
-    ]),
+    installationP,
+    chainTimerService,
   ]);
 
   const unitAmountIn = await unitAmount(brandIn);
@@ -140,14 +189,11 @@ export const createPriceFeed = async (
     timer,
     unitAmountIn,
   });
-  trace('got terms');
-
   const label = sanitizePathSegment(AGORIC_INSTANCE_NAME);
 
   const storageNode = await makeStorageNodeChild(chainStorage, STORAGE_PATH);
   const marshaller = await E(board).getReadonlyMarshaller();
 
-  trace('awaiting startInstance');
   const faKit = await E(startGovernedUpgradable)({
     governedParams: {},
     privateArgs: {
@@ -158,30 +204,38 @@ export const createPriceFeed = async (
     },
     terms,
     label,
-    installation: priceAggregator,
+    installation,
   });
 
-  E(E(agoricNamesAdmin).lookupAdmin('instance'))
+  // Publish price feed in home.priceAuthority.
+  const forceReplace = true;
+  // Make sure this PA is registered before sharing the instance in agoricNames,
+  // which allows contracts that depend on the registry value to wait for it and
+  // prevent a race.
+  await E(priceAuthorityAdmin).registerPriceAuthority(
+    E(faKit.publicFacet).getPriceAuthority(),
+    brandIn,
+    brandOut,
+    forceReplace,
+  );
+
+  await E(E(agoricNamesAdmin).lookupAdmin('instance'))
     .update(AGORIC_INSTANCE_NAME, faKit.instance)
     .catch(err =>
       console.error(`🚨 failed to update ${AGORIC_INSTANCE_NAME}`, err),
     );
 
+  // being after the above awaits means that when this resolves, the consumer
+  // gets notified that the authority is in the registry and its instance is in
+  // agoricNames. reset() in case we're replacing an existing feed.
+  produceInstance[AGORIC_INSTANCE_NAME].reset();
+  produceInstance[AGORIC_INSTANCE_NAME].resolve(faKit.instance);
+
   E(E.get(econCharterKit).creatorFacet).addInstance(
     faKit.instance,
     faKit.governorCreatorFacet,
     AGORIC_INSTANCE_NAME,
   );
-  trace('registered', AGORIC_INSTANCE_NAME, faKit.instance);
-
-  // Publish price feed in home.priceAuthority.
-  const forceReplace = true;
-  void E(priceAuthorityAdmin).registerPriceAuthority(
-    E(faKit.publicFacet).getPriceAuthority(),
-    brandIn,
-    brandOut,
-    forceReplace,
-  );
 
   /**
    * Initialize a new oracle and send an invitation to administer it.
@@ -190,22 +244,23 @@ export const createPriceFeed = async (
    */
   const addOracle = async addr => {
     const invitation = await E(faKit.creatorFacet).makeOracleInvitation(addr);
-    await reserveThenDeposit(
-      `${AGORIC_INSTANCE_NAME} member ${addr}`,
-      namesByAddressAdmin,
-      addr,
-      [invitation],
-    );
+    const debugName = `${AGORIC_INSTANCE_NAME} member ${addr}`;
+    await reserveThenDeposit(debugName, namesByAddressAdmin, addr, [
+      invitation,
+    ]).catch(err => console.error(`failed deposit to ${debugName}`, err));
   };
 
   trace('distributing invitations', oracleAddresses);
-  await Promise.all(oracleAddresses.map(addOracle));
+  // This doesn't resolve until oracle operators create their smart wallets.
+  // Don't block bootstrap on it.
+  void Promise.all(oracleAddresses.map(addOracle));
   trace('createPriceFeed complete');
 };
 
 const t = 'priceFeed';
 /**
- * Add a price feed to a running chain, returning the manifest, installations, and options.
+ * Add a price feed to a running chain, returning the manifest, installations,
+ * and options.
  *
  * @param {object} utils
  * @param {(ref: unknown) => Promise<unknown>} [utils.restoreRef]
@@ -223,14 +278,16 @@ export const getManifestForPriceFeed = async (
         chainStorage: t,
         chainTimerService: t,
         client: t,
-        contractGovernor: t,
         econCharterKit: t,
-        economicCommitteeCreatorFacet: t,
         highPrioritySendersManager: t,
         namesByAddressAdmin: t,
         priceAuthority: t,
         priceAuthorityAdmin: t,
         startGovernedUpgradable: t,
+        zoe: t,
+      },
+      instance: {
+        produce: t,
       },
     },
     [ensureOracleBrands.name]: {
@@ -243,6 +300,7 @@ export const getManifestForPriceFeed = async (
     },
   },
   installations: {
+    // ??? will every eval of price-feed-proposal install priceAggregator ?
     priceAggregator: restoreRef(priceFeedOptions.priceAggregatorRef),
   },
   options: {
@@ -258,7 +316,7 @@ export const getManifestForPriceFeed = async (
 });
 
 /**
- * @param {import('./econ-behaviors').EconomyBootstrapPowers} powers
+ * @param {import('./econ-behaviors.js').EconomyBootstrapPowers} powers
  * @param {object} [config]
  * @param {object} [config.options]
  * @param {string[]} [config.options.demoOracleAddresses]
@@ -303,7 +361,7 @@ export const startPriceFeeds = async (
     {
       options: {
         priceFeedOptions: {
-          AGORIC_INSTANCE_NAME: `${inBrandName}-${outBrandName} price feed`,
+          AGORIC_INSTANCE_NAME: oracleBrandFeedName(inBrandName, outBrandName),
           contractTerms: {
             minSubmissionCount: 2,
             minSubmissionValue: 1,

package/src/proposals/replace-fee-distributor.d.ts

@@ -0,0 +1,48 @@
+export function replaceFeeDistributor({ consume: { chainTimerService, bankManager, vaultFactoryKit, periodicFeeCollectors, reserveKit, zoe, contractKits: contractKitsP, }, produce: { feeDistributorKit, periodicFeeCollectors: periodicFeeCollectorsP, }, instance: { produce: { feeDistributor: feeDistributorP }, }, installation: { consume: { feeDistributor }, }, issuer: { consume: { [Stable.symbol]: centralIssuerP }, }, brand: { consume: { [Stable.symbol]: centralBrandP }, }, }: import("./econ-behaviors").EconomyBootstrapPowers, { options }: {
+    options: {
+        keywordShares: Record<string, bigint>;
+        collectionInterval: bigint;
+    };
+}): Promise<void>;
+export function getManifestForReplaceFeeDistributor(_: any, feeDistributorOptions: any): Promise<{
+    manifest: {
+        [x: string]: {
+            consume: {
+                chainTimerService: string;
+                bankManager: string;
+                vaultFactoryKit: string;
+                periodicFeeCollectors: string;
+                reserveKit: string;
+                zoe: string;
+                contractKits: string;
+            };
+            produce: {
+                feeDistributorKit: string;
+                periodicFeeCollectors: string;
+            };
+            instance: {
+                produce: {
+                    feeDistributor: string;
+                };
+            };
+            installation: {
+                consume: {
+                    feeDistributor: string;
+                };
+            };
+            issuer: {
+                consume: {
+                    IST: string;
+                };
+            };
+            brand: {
+                consume: {
+                    IST: string;
+                };
+            };
+        };
+    };
+    options: any;
+}>;
+import { Stable } from '@agoric/internal/src/tokens.js';
+//# sourceMappingURL=replace-fee-distributor.d.ts.map

package/src/proposals/replace-fee-distributor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replace-fee-distributor.d.ts","sourceRoot":"","sources":["replace-fee-distributor.js"],"names":[],"mappings":"AAkBO,geARI,OAAO,kBAAkB,EAAE,sBAAsB,eACjD;IACN,OAAO,EAAE;QACP,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACtC,kBAAkB,EAAE,MAAM,CAAC;KAC5B,CAAC;CACH,iBA4IH;AAIM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCL;uBAjMqB,gCAAgC"}