agoric 0.20.0 → 0.21.0

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.21.0](https://github.com/Agoric/agoric-sdk/compare/agoric@0.20.0...agoric@0.21.0) (2023-06-02)
+
+
+### Features
+
+* **agoric-cli:** oracle setPrice: pushPrice from each operator ([9004c46](https://github.com/Agoric/agoric-sdk/commit/9004c46cf65a163795621a415a97fcaee47ac983))
+* **clientSupport:** Offers.fluxAggregator.PushPrice ([bae997a](https://github.com/Agoric/agoric-sdk/commit/bae997ae9d28bad0ec02896975044f27c64d123d))
+
+
+
 ## [0.20.0](https://github.com/Agoric/agoric-sdk/compare/agoric@0.19.0...agoric@0.20.0) (2023-05-24)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agoric",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Manage the Agoric Javascript smart contract platform",
   "type": "module",
   "main": "src/main.js",
@@ -24,25 +24,25 @@
     "lint:eslint": "eslint ."
   },
   "devDependencies": {
-    "@agoric/deploy-script-support": "^0.10.1",
+    "@agoric/deploy-script-support": "^0.10.2",
     "ava": "^5.2.0",
     "c8": "^7.13.0"
   },
   "dependencies": {
     "@agoric/access-token": "^0.4.21",
     "@agoric/assert": "^0.6.0",
-    "@agoric/cache": "^0.3.1",
-    "@agoric/casting": "^0.4.1",
+    "@agoric/cache": "^0.3.2",
+    "@agoric/casting": "^0.4.2",
     "@agoric/cosmic-proto": "^0.3.0",
-    "@agoric/ertp": "^0.16.1",
-    "@agoric/inter-protocol": "^0.15.0",
-    "@agoric/internal": "^0.3.1",
-    "@agoric/smart-wallet": "^0.5.1",
-    "@agoric/store": "^0.9.1",
-    "@agoric/swingset-vat": "^0.32.1",
-    "@agoric/vats": "^0.14.1",
-    "@agoric/zoe": "^0.26.1",
-    "@agoric/zone": "^0.2.1",
+    "@agoric/ertp": "^0.16.2",
+    "@agoric/inter-protocol": "^0.16.0",
+    "@agoric/internal": "^0.3.2",
+    "@agoric/smart-wallet": "^0.5.2",
+    "@agoric/store": "^0.9.2",
+    "@agoric/swingset-vat": "^0.32.2",
+    "@agoric/vats": "^0.15.0",
+    "@agoric/zoe": "^0.26.2",
+    "@agoric/zone": "^0.2.2",
     "@confio/relayer": "^0.9.0",
     "@cosmjs/crypto": "^0.30.1",
     "@cosmjs/encoding": "^0.30.1",
@@ -88,5 +88,5 @@
     "timeout": "2m",
     "workerThreads": false
   },
-  "gitHead": "676e947a6fba6e1bab0717ca7228824c32509bda"
+  "gitHead": "b66bf7c881ae462fcb617cd6e8d41b5c40ec58ef"
 }

package/src/commands/oracle.js

@@ -2,13 +2,22 @@
 /* eslint-disable @jessie.js/no-nested-await */
 // @ts-check
 /* eslint-disable func-names */
-/* global fetch */
+/* global fetch, setTimeout, process */
 import { Fail } from '@agoric/assert';
+import { Offers } from '@agoric/inter-protocol/src/clientSupport.js';
 import { Nat } from '@endo/nat';
 import { Command } from 'commander';
+import * as cp from 'child_process';
 import { inspect } from 'util';
-import { makeRpcUtils, storageHelper } from '../lib/rpc.js';
-import { getCurrent, outputAction } from '../lib/wallet.js';
+import { normalizeAddressWithOptions } from '../lib/chain.js';
+import { getNetworkConfig, makeRpcUtils, storageHelper } from '../lib/rpc.js';
+import {
+  getCurrent,
+  makeWalletUtils,
+  outputAction,
+  sendAction,
+} from '../lib/wallet.js';
+import { bigintReplacer } from '../lib/format.js';
 
 // XXX support other decimal places
 const COSMOS_UNIT = 1_000_000n;
@@ -16,10 +25,24 @@ const scaleDecimals = num => BigInt(num * Number(COSMOS_UNIT));
 
 /**
  * @param {import('anylogger').Logger} logger
+ * @param {{
+ *   delay?: (ms: number) => Promise<void>,
+ *   execFileSync?: typeof import('child_process').execFileSync,
+ *   env?: Record<string, string | undefined>,
+ *   stdout?: Pick<import('stream').Writable,'write'>,
+ * }} [io]
  */
-export const makeOracleCommand = logger => {
-  const oracle = new Command('oracle').description('Oracle commands').usage(
-    `
+export const makeOracleCommand = (logger, io = {}) => {
+  const {
+    delay = ms => new Promise(resolve => setTimeout(resolve, ms)),
+    execFileSync = cp.execFileSync,
+    env = process.env,
+    stdout = process.stdout,
+  } = io;
+  const oracle = new Command('oracle')
+    .description('Oracle commands')
+    .usage(
+      `
   WALLET=my-wallet
   export AGORIC_NET=ollinet
 
@@ -39,9 +62,18 @@ export const makeOracleCommand = logger => {
   # sign and send
   agoric wallet send --from $WALLET --offer offer-12.json
   `,
-  );
+    )
+    .option(
+      '--keyring-backend <os|file|test>',
+      `keyring's backend (os|file|test) (default "${
+        env.AGORIC_KEYRING_BACKEND || 'os'
+      }")`,
+      env.AGORIC_KEYRING_BACKEND,
+    );
 
   const rpcTools = async () => {
+    // XXX pass fetch to getNetworkConfig() explicitly
+    const networkConfig = await getNetworkConfig(env);
     const utils = await makeRpcUtils({ fetch });
 
     const lookupPriceAggregatorInstance = ([brandIn, brandOut]) => {
@@ -54,7 +86,7 @@ export const makeOracleCommand = logger => {
       return instance;
     };
 
-    return { ...utils, lookupPriceAggregatorInstance };
+    return { ...utils, networkConfig, lookupPriceAggregatorInstance };
   };
 
   oracle
@@ -95,37 +127,6 @@ export const makeOracleCommand = logger => {
       console.warn('Now execute the prepared offer');
     });
 
-  oracle
-    .command('pushPrice')
-    .description('add a current price sample to a priceAggregator')
-    .option('--offerId <string>', 'Offer id', String, `pushPrice-${Date.now()}`)
-    .requiredOption(
-      '--oracleAdminAcceptOfferId <number>',
-      'offer that had continuing invitation result',
-      Number,
-    )
-    .requiredOption('--price <number>', 'price (format TODO)', String)
-    .action(async function (opts) {
-      /** @type {import('@agoric/smart-wallet/src/offers.js').OfferSpec} */
-      const offer = {
-        id: opts.offerId,
-        invitationSpec: {
-          source: 'continuing',
-          previousOffer: opts.oracleAdminAcceptOfferId,
-          invitationMakerName: 'PushPrice',
-          invitationArgs: harden([opts.price]),
-        },
-        proposal: {},
-      };
-
-      outputAction({
-        method: 'executeOffer',
-        offer,
-      });
-
-      console.warn('Now execute the prepared offer');
-    });
-
   oracle
     .command('pushPriceRound')
     .description('add a price for a round to a fluxAggregator')
@@ -143,19 +144,15 @@ export const makeOracleCommand = logger => {
     .requiredOption('--price <number>', 'price', Number)
     .option('--roundId <number>', 'round', Number)
     .action(async function (opts) {
+      const { offerId } = opts;
       const unitPrice = scaleDecimals(opts.price);
       const roundId = 'roundId' in opts ? Nat(opts.roundId) : undefined;
-      /** @type {import('@agoric/smart-wallet/src/offers.js').OfferSpec} */
-      const offer = {
-        id: opts.offerId,
-        invitationSpec: {
-          source: 'continuing',
-          previousOffer: opts.oracleAdminAcceptOfferId,
-          invitationMakerName: 'PushPrice',
-          invitationArgs: harden([{ unitPrice, roundId }]),
-        },
-        proposal: {},
-      };
+
+      const offer = Offers.fluxAggregator.PushPrice(
+        {},
+        { offerId, unitPrice, roundId },
+        opts.oracleAdminAcceptOfferId,
+      );
 
       outputAction({
         method: 'executeOffer',
@@ -165,27 +162,33 @@ export const makeOracleCommand = logger => {
       console.warn('Now execute the prepared offer');
     });
 
+  const findOracleCap = async (from, readLatestHead) => {
+    const current = await getCurrent(from, { readLatestHead });
+
+    const { offerToUsedInvitation: entries } = /** @type {any} */ (current);
+    Array.isArray(entries) || Fail`entries must be an array: ${entries}`;
+
+    for (const [offerId, { value }] of entries) {
+      /** @type {{ description: string, instance: unknown }[]} */
+      const [{ description }] = value;
+      if (description === 'oracle invitation') {
+        return offerId;
+      }
+    }
+  };
+
   oracle
     .command('find-continuing-id')
     .description('print id of specified oracle continuing invitation')
     .requiredOption('--from <address>', 'from address', String)
     .action(async opts => {
       const { readLatestHead } = await makeRpcUtils({ fetch });
-      const current = await getCurrent(opts.from, { readLatestHead });
-
-      const { offerToUsedInvitation: entries } = /** @type {any} */ (current);
-      Array.isArray(entries) || Fail`entries must be an array: ${entries}`;
 
-      for (const [offerId, { value }] of entries) {
-        /** @type {{ description: string, instance: unknown }[]} */
-        const [{ description }] = value;
-        if (description === 'oracle invitation') {
-          console.log(offerId);
-          return;
-        }
+      const offerId = await findOracleCap(opts.from, readLatestHead);
+      if (!offerId) {
+        console.error('No continuing ids found');
       }
-
-      console.error('No continuing ids found');
+      console.log(offerId);
     });
 
   oracle
@@ -208,5 +211,141 @@ export const makeOracleCommand = logger => {
 
       console.log(inspect(capDatas[0], { depth: 10, colors: true }));
     });
+
+  /** @param {string} literalOrName */
+  const normalizeAddress = literalOrName =>
+    normalizeAddressWithOptions(literalOrName, oracle.opts(), {
+      execFileSync,
+    });
+  const show = (info, indent = false) =>
+    stdout.write(
+      `${JSON.stringify(info, bigintReplacer, indent ? 2 : undefined)}\n`,
+    );
+  /** @param {bigint} secs */
+  const fmtSecs = secs => new Date(Number(secs) * 1000).toISOString();
+
+  oracle
+    .command('setPrice')
+    .description('set price by pushing from multiple operators')
+    .requiredOption(
+      '--pair [brandIn.brandOut]',
+      'token pair (brandIn.brandOut)',
+      s => s.split('.'),
+      ['ATOM', 'USD'],
+    )
+    .requiredOption(
+      '--keys [key1,key2,...]',
+      'key names of operators (comma separated)',
+      s => s.split(','),
+      ['gov1', 'gov2'],
+    )
+    .requiredOption('--price <number>', 'price', Number)
+    .action(
+      async (
+        /**
+         * @type {{
+         *  pair: [brandIn: string, brandOut: string],
+         *  keys: string[],
+         *  price: number,
+         * }}
+         */ { pair, keys, price },
+      ) => {
+        const { readLatestHead, networkConfig } = await rpcTools();
+        const wutil = await makeWalletUtils(
+          { fetch, execFileSync, delay },
+          networkConfig,
+        );
+        const unitPrice = scaleDecimals(price);
+
+        console.error(`${pair[0]}-${pair[1]}_price_feed: before setPrice`);
+
+        const readPrice = () =>
+          /** @type {Promise<PriceDescription>} */ (
+            readLatestHead(
+              `published.priceFeed.${pair[0]}-${pair[1]}_price_feed`,
+            ).catch(err => {
+              console.warn(`cannot get ${pair[0]}-${pair[1]}_price_feed`, err);
+              return undefined;
+            })
+          );
+
+        const r4 = x => Math.round(x * 10000) / 10000; // XXX 4 decimals arbitrary
+        const fmtFeed = ({
+          amountIn: { value: valueIn },
+          amountOut: { value: valueOut },
+          timestamp: { absValue: ts },
+        }) => ({
+          timestamp: fmtSecs(ts),
+          price: r4(Number(valueOut) / Number(valueIn)),
+        });
+        const before = await readPrice();
+        if (before) {
+          show(fmtFeed(before));
+        }
+
+        console.error(
+          'Choose lead oracle operator order based on latestRound...',
+        );
+        const keyOrder = keys.map(normalizeAddress);
+        const latestRoundP = readLatestHead(
+          `published.priceFeed.${pair[0]}-${pair[1]}_price_feed.latestRound`,
+        );
+        await Promise.race([
+          delay(5000),
+          latestRoundP.then(round => {
+            // @ts-expect-error XXX get type from contract
+            const { roundId, startedAt, startedBy } = round;
+            show({
+              startedAt: fmtSecs(startedAt.absValue),
+              roundId,
+              startedBy,
+            });
+            if (startedBy === keyOrder[0]) {
+              keyOrder.reverse();
+            }
+          }),
+        ]).catch(err => {
+          console.warn(err);
+        });
+
+        console.error('pushPrice from each:', keyOrder);
+        for await (const from of keyOrder) {
+          const oracleAdminAcceptOfferId = await findOracleCap(
+            from,
+            readLatestHead,
+          );
+          if (!oracleAdminAcceptOfferId) {
+            throw Error(`no oracle invitation found: ${from}`);
+          }
+          show({ from, oracleAdminAcceptOfferId });
+          const offerId = `pushPrice-${Date.now()}`;
+          const offer = Offers.fluxAggregator.PushPrice(
+            {},
+            { offerId, unitPrice },
+            oracleAdminAcceptOfferId,
+          );
+
+          const { home, keyringBackend: backend } = oracle.opts();
+          const tools = { ...networkConfig, execFileSync, delay, stdout };
+          const result = await sendAction(
+            { method: 'executeOffer', offer },
+            { keyring: { home, backend }, from, verbose: false, ...tools },
+          );
+          assert(result); // Not dry-run
+          const { timestamp, txhash, height } = result;
+          console.error('pushPrice', price, 'offer broadcast');
+          show({ timestamp, height, offerId: offer.id, txhash });
+          const found = await wutil.pollOffer(from, offer.id, result.height);
+          console.error('pushPrice', price, 'offer satisfied');
+          show(found);
+        }
+
+        const after = await readPrice();
+        if (after) {
+          console.error('price set:');
+          show(fmtFeed(after));
+        }
+      },
+    );
   return oracle;
 };