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

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

@@ -1,23 +1,48 @@
+// @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 {
   makeStorageNodeChild,
   assertPathSegment,
-} from '@agoric/vats/src/lib-chainStorage.js';
-import { deeplyFulfilledObject } from '@agoric/internal';
+} from '@agoric/internal/src/lib-chainStorage.js';
+import { makeTracer } from '@agoric/internal';
 
 import { unitAmount } from '@agoric/zoe/src/contractSupport/priceQuote.js';
 import { reserveThenDeposit, reserveThenGetNames } from './utils.js';
 
-/** @type {(name: string) => void} */
+const trace = makeTracer('RunPriceFeed', true);
+
+/** @type {(name: string) => string} */
 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 & NamedVatPowers} space
+ * @param {{options: {priceFeedOptions: PriceFeedOptions}}} opt
+ * @returns {Promise<[Brand<'nat'>, Brand<'nat'>]>}
+ */
 export const ensureOracleBrands = async (
-  { consume: { agoricNamesAdmin } },
+  {
+    namedVat: {
+      consume: { agoricNames },
+    },
+    oracleBrand: { produce: oracleBrandProduce },
+  },
   {
     options: {
       priceFeedOptions: {
@@ -31,28 +56,19 @@ export const ensureOracleBrands = async (
     },
   },
 ) => {
-  /** @type {NameAdmin} */
-  const obAdmin = E(agoricNamesAdmin).lookupAdmin('oracleBrand');
+  trace('ensureOracleBrands');
 
   const updateFreshBrand = async (brand, name, decimals) => {
-    const b = await brand;
-    if (b) {
-      // Don't update if it was already set.
-      return b;
+    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) }),
+      );
     }
-    const freshBrand = makeIssuerKit(
-      name,
-      undefined,
-      harden({ decimalPlaces: parseInt(decimals, 10) }),
-    ).brand;
-
-    if (!name) {
-      // Don't update unnamed brands.
-      return freshBrand;
-    }
-
-    // Atomically update if not already set.
-    return E(obAdmin).default(name, freshBrand);
+    oracleBrandProduce[name].resolve(b);
   };
 
   return Promise.all([
@@ -63,23 +79,23 @@ export const ensureOracleBrands = async (
 
 /**
  * @param {ChainBootstrapSpace} powers
- * @param {{options: {priceFeedOptions: {AGORIC_INSTANCE_NAME: string, oracleAddresses: UNKNOWN, contractTerms: unknown, 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}}}} config
  */
 export const createPriceFeed = async (
   {
     consume: {
       agoricNamesAdmin,
-      aggregators,
       board,
       chainStorage,
       chainTimerService,
       client,
+      econCharterKit,
+      highPrioritySendersManager,
       namesByAddressAdmin,
       priceAuthority,
       priceAuthorityAdmin,
-      zoe,
+      startGovernedUpgradable,
     },
-    produce: { aggregators: produceAggregators },
   },
   {
     options: {
@@ -93,18 +109,17 @@ export const createPriceFeed = async (
     },
   },
 ) => {
+  trace('createPriceFeed');
   const STORAGE_PATH = 'priceFeed';
 
-  // Default to an empty Map and home.priceAuthority.
-  produceAggregators.resolve(new Map());
-  E(client).assignBundle([_addr => ({ priceAuthority })]);
+  void E(client).assignBundle([_addr => ({ priceAuthority })]);
 
   const timer = await chainTimerService;
 
   /**
    * Values come from economy-template.json, which at this writing had IN:ATOM, OUT:USD
    *
-   * @type {[[Brand, Brand], [Installation<import('@agoric/zoe/src/contracts/priceAggregator.js').start>]]}
+   * @type {[[Brand<'nat'>, Brand<'nat'>], [Installation<import('@agoric/inter-protocol/src/price/fluxAggregatorContract.js').prepare>]]}
    */
   const [[brandIn, brandOut], [priceAggregator]] = await Promise.all([
     reserveThenGetNames(E(agoricNamesAdmin).lookupAdmin('oracleBrand'), [
@@ -117,61 +132,64 @@ export const createPriceFeed = async (
   ]);
 
   const unitAmountIn = await unitAmount(brandIn);
-  /** @type {import('@agoric/zoe/src/contracts/priceAggregator.js').PriceAggregatorContract['terms']} */
-  const terms = await deeplyFulfilledObject(
-    harden({
-      ...contractTerms,
-      description: AGORIC_INSTANCE_NAME,
-      brandIn,
-      brandOut,
-      timer,
-      unitAmountIn,
-    }),
-  );
-  terms.absent;
+  const terms = harden({
+    ...contractTerms,
+    description: AGORIC_INSTANCE_NAME,
+    brandIn,
+    brandOut,
+    timer,
+    unitAmountIn,
+  });
+  trace('got terms');
+
+  const label = sanitizePathSegment(AGORIC_INSTANCE_NAME);
 
   const storageNode = await makeStorageNodeChild(chainStorage, STORAGE_PATH);
-  const marshaller = E(board).getReadonlyMarshaller();
+  const marshaller = await E(board).getReadonlyMarshaller();
 
-  // Create the price feed.
-  const aggregator = await E(zoe).startInstance(
-    priceAggregator,
-    undefined,
-    terms,
-    {
-      storageNode: E(storageNode).makeChildNode(
-        sanitizePathSegment(AGORIC_INSTANCE_NAME),
-      ),
+  trace('awaiting startInstance');
+  const faKit = await E(startGovernedUpgradable)({
+    governedParams: {},
+    privateArgs: {
+      highPrioritySendersManager: await highPrioritySendersManager,
       marshaller,
+      namesByAddressAdmin,
+      storageNode: await E(storageNode).makeChildNode(label),
     },
-  );
-  E(aggregators).set(terms, { aggregator });
+    terms,
+    label,
+    installation: priceAggregator,
+  });
 
-  E(E(agoricNamesAdmin).lookupAdmin('instance')).update(
+  E(E(agoricNamesAdmin).lookupAdmin('instance'))
+    .update(AGORIC_INSTANCE_NAME, faKit.instance)
+    .catch(err =>
+      console.error(`🚨 failed to update ${AGORIC_INSTANCE_NAME}`, err),
+    );
+
+  E(E.get(econCharterKit).creatorFacet).addInstance(
+    faKit.instance,
+    faKit.governorCreatorFacet,
     AGORIC_INSTANCE_NAME,
-    aggregator.instance,
   );
+  trace('registered', AGORIC_INSTANCE_NAME, faKit.instance);
 
   // Publish price feed in home.priceAuthority.
   const forceReplace = true;
-  E(priceAuthorityAdmin)
-    .registerPriceAuthority(
-      E(aggregator.publicFacet).getPriceAuthority(),
-      brandIn,
-      brandOut,
-      forceReplace,
-    )
-    .then(deleter => E(aggregators).set(terms, { aggregator, deleter }));
+  void E(priceAuthorityAdmin).registerPriceAuthority(
+    E(faKit.publicFacet).getPriceAuthority(),
+    brandIn,
+    brandOut,
+    forceReplace,
+  );
 
   /**
-   * Send an invitation to one of the oracles.
+   * Initialize a new oracle and send an invitation to administer it.
    *
    * @param {string} addr
    */
-  const distributeInvitation = async addr => {
-    const invitation = await E(aggregator.creatorFacet).makeOracleInvitation(
-      addr,
-    );
+  const addOracle = async addr => {
+    const invitation = await E(faKit.creatorFacet).makeOracleInvitation(addr);
     await reserveThenDeposit(
       `${AGORIC_INSTANCE_NAME} member ${addr}`,
       namesByAddressAdmin,
@@ -180,11 +198,19 @@ export const createPriceFeed = async (
     );
   };
 
-  await Promise.all(oracleAddresses.map(distributeInvitation));
+  trace('distributing invitations', oracleAddresses);
+  await Promise.all(oracleAddresses.map(addOracle));
+  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,
@@ -192,22 +218,27 @@ export const getManifestForPriceFeed = async (
   manifest: {
     [createPriceFeed.name]: {
       consume: {
-        aggregators: t,
         agoricNamesAdmin: t,
         board: t,
         chainStorage: t,
         chainTimerService: t,
         client: t,
+        contractGovernor: t,
+        econCharterKit: t,
+        economicCommitteeCreatorFacet: t,
+        highPrioritySendersManager: t,
         namesByAddressAdmin: t,
         priceAuthority: t,
         priceAuthorityAdmin: t,
-        zoe: t,
+        startGovernedUpgradable: t,
       },
-      produce: { aggregators: t },
     },
     [ensureOracleBrands.name]: {
-      consume: {
-        agoricNamesAdmin: t,
+      namedVat: {
+        consume: { agoricNames: 'agoricNames' },
+      },
+      oracleBrand: {
+        produce: t,
       },
     },
   },
@@ -225,3 +256,69 @@ 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: {
+            minSubmissionCount: 2,
+            minSubmissionValue: 1,
+            maxSubmissionCount: 5,
+            maxSubmissionValue: 99999,
+            restartDelay: 1n,
+            timeout: 10,
+          },
+          oracleAddresses: demoOracleAddresses,
+          IN_BRAND_NAME: inBrandName,
+          OUT_BRAND_NAME: outBrandName,
+        },
+      },
+    },
+  );
+  trace('startPriceFeeds complete');
+};
+harden(startPriceFeeds);

package/src/proposals/startEconCommittee.js

@@ -1,12 +1,11 @@
-// @ts-check
+import { makeTracer } from '@agoric/internal';
 import {
   assertPathSegment,
   makeStorageNodeChild,
-} from '@agoric/vats/src/lib-chainStorage.js';
+} from '@agoric/internal/src/lib-chainStorage.js';
 import { E } from '@endo/far';
-import { makeTracer } from '../makeTracer.js';
 
-const trace = makeTracer('RunEconBehaviors', false);
+const trace = makeTracer('RunEconCommittee', true);
 
 /** @type {(name: string) => string} */
 const sanitizePathSegment = name => {
@@ -29,8 +28,8 @@ const sanitizePathSegment = name => {
  */
 export const startEconomicCommittee = async (
   {
-    consume: { board, chainStorage, zoe },
-    produce: { economicCommitteeCreatorFacet },
+    consume: { board, chainStorage, diagnostics, zoe },
+    produce: { economicCommitteeKit, economicCommitteeCreatorFacet },
     installation: {
       consume: { committee },
     },
@@ -60,16 +59,26 @@ export const startEconomicCommittee = async (
   // NB: committee must only publish what it intended to be public
   const marshaller = await E(board).getPublishingMarshaller();
 
-  const { creatorFacet, instance } = await E(zoe).startInstance(
+  const privateArgs = {
+    storageNode,
+    marshaller,
+  };
+  const startResult = await E(zoe).startInstance(
     committee,
     {},
     { committeeName, committeeSize, ...rest },
-    {
-      storageNode,
-      marshaller,
-    },
+    privateArgs,
+    'economicCommittee',
+  );
+  const { creatorFacet, instance } = startResult;
+
+  economicCommitteeKit.resolve(
+    // XXX should startInstance return its label?
+    harden({ ...startResult, label: 'economicCommittee' }),
   );
 
+  await E(diagnostics).savePrivateArgs(startResult.instance, privateArgs);
+
   economicCommitteeCreatorFacet.resolve(creatorFacet);
   economicCommittee.resolve(instance);
 };
@@ -80,9 +89,13 @@ export const ECON_COMMITTEE_MANIFEST = harden({
     consume: {
       board: true,
       chainStorage: true,
+      diagnostics: true,
       zoe: true,
     },
-    produce: { economicCommitteeCreatorFacet: 'economicCommittee' },
+    produce: {
+      economicCommitteeKit: true,
+      economicCommitteeCreatorFacet: 'economicCommittee',
+    },
     installation: {
       consume: { committee: 'zoe' },
     },