@agoric/inter-protocol 0.16.2-other-dev-8f8782b.0 → 0.16.2-other-dev-fbe72e7.0.fbe72e7

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.js

@@ -0,0 +1,198 @@
+import { deeplyFulfilledObject, makeTracer } from '@agoric/internal';
+import { Stable } from '@agoric/internal/src/tokens.js';
+import { makeScalarBigMapStore } from '@agoric/vat-data';
+import { getInterfaceOf, E } from '@endo/far';
+
+const trace = makeTracer('ReplaceFeeDistributer', true);
+
+/**
+ * Start the reward distributor.
+ *
+ * @param {import('./econ-behaviors').EconomyBootstrapPowers} powers
+ * @param {{
+ *   options: {
+ *     keywordShares: Record<string, bigint>;
+ *     collectionInterval: bigint;
+ *   };
+ * }} options
+ */
+export const replaceFeeDistributor = async (
+  {
+    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 },
+    },
+  },
+  { options },
+) => {
+  trace('replaceFeeDistributer', options);
+
+  const { keywordShares, collectionInterval } = options;
+
+  const feeDistributorTerms = await deeplyFulfilledObject(
+    harden({
+      timerService: chainTimerService,
+      collectionInterval,
+      keywordShares,
+    }),
+  );
+  trace('feeDistributorTerms', feeDistributorTerms);
+
+  const [centralIssuer, centralBrand, contractKits] = await Promise.all([
+    centralIssuerP,
+    centralBrandP,
+    contractKitsP,
+  ]);
+
+  const rewardDistributorDepositFacet = await E(bankManager)
+    .getRewardDistributorDepositFacet(Stable.denom, {
+      issuer: centralIssuer,
+      brand: centralBrand,
+    })
+    .catch(e => {
+      console.error('Cannot create fee collector deposit facet', e);
+      return undefined;
+    });
+
+  /**
+   * @type {StartedInstanceKit<
+   *   typeof import('@agoric/inter-protocol/src/feeDistributor.js').start
+   * >}
+   */
+  const instanceKit = await E(zoe).startInstance(
+    feeDistributor,
+    { Fee: centralIssuer },
+    feeDistributorTerms,
+    undefined,
+    'feeDistributor',
+  );
+  await E(instanceKit.creatorFacet).setDestinations({
+    ...(rewardDistributorDepositFacet && {
+      RewardDistributor: E(
+        instanceKit.creatorFacet,
+      ).makeDepositFacetDestination(rewardDistributorDepositFacet),
+    }),
+    Reserve: E(instanceKit.creatorFacet).makeOfferDestination(
+      zoe,
+      'Collateral',
+      E.get(reserveKit).publicFacet,
+      'makeAddCollateralInvitation',
+    ),
+  });
+
+  trace('Clearing the old instance from bootstrap powers...');
+  feeDistributorKit.reset();
+  feeDistributorP.reset();
+
+  trace('Now introduce the new instance');
+  feeDistributorKit.resolve(
+    harden({ ...instanceKit, label: 'feeDistributor' }),
+  );
+  feeDistributorP.resolve(instanceKit.instance);
+
+  const periodicCollectors = await periodicFeeCollectors;
+  trace(
+    `Stop periodicCollectors of the old instance. Number of collectors: ${periodicCollectors.getSize()}`,
+  );
+  for await (const [key, collector] of periodicCollectors.entries()) {
+    trace('Getting debugName', key);
+    // @ts-expect-error incomplete PeriodicFeeCollector type
+    const debugName = await E(collector).getDebugName();
+    trace(`Stopping ${debugName}...`);
+    await E(collector).stop();
+  }
+  periodicFeeCollectorsP.reset();
+
+  trace('Old collectors cleared. Start creating and setting new ones.');
+
+  const collectorKit = {
+    vaultFactory: E.get(vaultFactoryKit).creatorFacet,
+  };
+  const newCollectorStore = makeScalarBigMapStore('periodicCollectors', {
+    durable: true,
+  });
+  await Promise.all(
+    Object.entries(collectorKit).map(async ([debugName, collectorFacet]) => {
+      const collector = E(instanceKit.creatorFacet).makeContractFeeCollector(
+        zoe,
+        collectorFacet,
+      );
+      const periodicCollector = await E(
+        instanceKit.creatorFacet,
+      ).startPeriodicCollection(debugName, collector);
+      newCollectorStore.init(periodicCollectors.getSize(), periodicCollector);
+    }),
+  );
+
+  trace('Write newCollectorStore in periodicFeeCollectors');
+  periodicFeeCollectorsP.resolve(newCollectorStore);
+
+  trace('Write to contractKits');
+  const label = getInterfaceOf(instanceKit.instance);
+  const kit = harden({ ...instanceKit, label });
+  contractKits.init(kit.instance, kit);
+
+  trace('Done.');
+};
+harden(replaceFeeDistributor);
+
+const t = 'replaceFeeDistributor';
+export const getManifestForReplaceFeeDistributor = async (
+  { restoreRef },
+  { feeDistributorRef, ...feeDistributorOptions },
+) => ({
+  manifest: {
+    [replaceFeeDistributor.name]: {
+      consume: {
+        chainTimerService: t,
+        bankManager: t,
+        vaultFactoryKit: t,
+        periodicFeeCollectors: t,
+        reserveKit: t,
+        zoe: t,
+        contractKits: t,
+      },
+      produce: {
+        feeDistributorKit: t,
+        periodicFeeCollectors: t,
+      },
+      instance: {
+        produce: { feeDistributor: t },
+      },
+      installation: {
+        consume: { feeDistributor: t },
+      },
+      issuer: {
+        consume: { [Stable.symbol]: t },
+      },
+      brand: {
+        consume: { [Stable.symbol]: t },
+      },
+    },
+  },
+  installations: {
+    feeDistributor: restoreRef(feeDistributorRef),
+  },
+  options: { ...feeDistributorOptions },
+});

package/src/proposals/replace-scaledPriceAuthorities.js

@@ -0,0 +1,124 @@
+import { makeTracer } from '@agoric/internal';
+import { E } from '@endo/far';
+
+import { startScaledPriceAuthority } from './addAssetToVault.js';
+import { scaledPriceFeedName } from './utils.js';
+
+const trace = makeTracer('replaceScaledPA', true);
+
+/**
+ * @param {BootstrapPowers} powers
+ * @param {object} config
+ * @param {object} config.options
+ */
+export const replaceScaledPriceAuthority = async (powers, { options }) => {
+  const {
+    instance: { produce: produceInstance },
+  } = powers;
+  const { issuerName } = options.interchainAssetOptions;
+
+  const spaKit = await startScaledPriceAuthority(powers, { options });
+
+  const label = scaledPriceFeedName(issuerName);
+  produceInstance[label].reset();
+
+  // publish into agoricNames. This must stay after registerPriceAuthority,
+  // which is called by startScaledPriceAuthority()
+  produceInstance[label].resolve(spaKit.instance);
+};
+
+/**
+ * Look up the existing assets known to auctions, and replace the corresponding
+ * scaledPriceAuthorities. The existing contracts will be left behind to be
+ * cleaned up later.
+ *
+ * @param {ChainBootstrapSpace & BootstrapPowers} powers
+ * @param {{ options: { scaledPARef: { bundleID: string } } }} options
+ */
+export const replaceScaledPriceAuthorities = async (powers, { options }) => {
+  trace('start');
+  const {
+    consume: {
+      agoricNamesAdmin,
+      agoricNames,
+      contractKits: contractKitsP,
+      zoe,
+    },
+  } = powers;
+
+  const { scaledPARef } = options;
+
+  const installationsAdmin = E(agoricNamesAdmin).lookupAdmin('installation');
+  const [spaInstallation, contractKits] = await Promise.all([
+    E(E(installationsAdmin).readonly()).lookup('scaledPriceAuthority'),
+    contractKitsP,
+  ]);
+
+  const bundleID = scaledPARef.bundleID;
+  if (scaledPARef && bundleID) {
+    await E.when(
+      E(zoe).installBundleID(bundleID),
+      installation =>
+        E(installationsAdmin).update('scaledPriceAuthority', installation),
+      err =>
+        console.error(
+          `🚨 failed to update scaledPriceAuthority installation`,
+          err,
+        ),
+    );
+    trace('installed scaledPriceAuthority bundle', bundleID);
+  }
+
+  // Ask Zoe for the installation for each kit's instance, and return all the
+  // kits where that matches the given installation.
+  async function maybeSPAKit(kit) {
+    const installation = await E(zoe).getInstallationForInstance(kit.instance);
+    return spaInstallation === installation ? [kit] : [];
+  }
+  const scaledPAKits = (
+    await Promise.all([...contractKits.values()].map(maybeSPAKit))
+  ).flat();
+
+  const namedBrands = await E(E(agoricNames).lookup('brand')).entries();
+
+  for (const kitEntry of scaledPAKits) {
+    const { instance } = kitEntry;
+    const terms = await E(powers.consume.zoe).getTerms(instance);
+    const { brand } = terms.scaleIn.denominator;
+    const entry = namedBrands.find(([_k, v]) => v === brand);
+    assert(entry, 'unable to find issuerName for ', brand);
+    const issuerName = entry[0];
+    await replaceScaledPriceAuthority(powers, {
+      options: { interchainAssetOptions: { issuerName } },
+    });
+  }
+};
+
+const t = 'replaceScaledPriceAuthority';
+export const getManifestForReplaceScaledPriceAuthorities = async (
+  _ign,
+  upgradeSPAOptions,
+) => ({
+  manifest: {
+    [replaceScaledPriceAuthorities.name]: {
+      consume: {
+        // //// Widely known  ////
+        agoricNames: t,
+        priceAuthority: t,
+        startUpgradable: t,
+        zoe: t,
+
+        // //// closely held, powerful ////
+        agoricNamesAdmin: t,
+        contractKits: t,
+        priceAuthorityAdmin: t,
+      },
+      instance: {
+        // This is a right to add/replace any instance. That we update only the
+        // relevant ones must be verified by inspection.
+        produce: t,
+      },
+    },
+  },
+  options: { ...upgradeSPAOptions },
+});