agoric 0.19.1-dev-acefd94.0 → 0.19.1-dev-d42f8d0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agoric",
-  "version": "0.19.1-dev-acefd94.0+acefd94",
+  "version": "0.19.1-dev-d42f8d0.0+d42f8d0",
   "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-dev-acefd94.0+acefd94",
+    "@agoric/deploy-script-support": "0.10.1-dev-d42f8d0.0+d42f8d0",
     "ava": "^5.2.0",
     "c8": "^7.13.0"
   },
   "dependencies": {
-    "@agoric/access-token": "0.4.22-dev-acefd94.0+acefd94",
-    "@agoric/assert": "0.6.1-dev-acefd94.0+acefd94",
-    "@agoric/cache": "0.3.1-dev-acefd94.0+acefd94",
-    "@agoric/casting": "0.4.1-dev-acefd94.0+acefd94",
-    "@agoric/cosmic-proto": "0.3.1-dev-acefd94.0+acefd94",
-    "@agoric/ertp": "0.16.1-dev-acefd94.0+acefd94",
-    "@agoric/inter-protocol": "0.14.1-dev-acefd94.0+acefd94",
-    "@agoric/internal": "0.3.1-dev-acefd94.0+acefd94",
-    "@agoric/smart-wallet": "0.5.1-dev-acefd94.0+acefd94",
-    "@agoric/store": "0.9.1-dev-acefd94.0+acefd94",
-    "@agoric/swingset-vat": "0.32.1-dev-acefd94.0+acefd94",
-    "@agoric/vats": "0.14.1-dev-acefd94.0+acefd94",
-    "@agoric/zoe": "0.26.1-dev-acefd94.0+acefd94",
-    "@agoric/zone": "0.2.1-dev-acefd94.0+acefd94",
+    "@agoric/access-token": "0.4.22-dev-d42f8d0.0+d42f8d0",
+    "@agoric/assert": "0.6.1-dev-d42f8d0.0+d42f8d0",
+    "@agoric/cache": "0.3.1-dev-d42f8d0.0+d42f8d0",
+    "@agoric/casting": "0.4.1-dev-d42f8d0.0+d42f8d0",
+    "@agoric/cosmic-proto": "0.3.1-dev-d42f8d0.0+d42f8d0",
+    "@agoric/ertp": "0.16.1-dev-d42f8d0.0+d42f8d0",
+    "@agoric/inter-protocol": "0.14.1-dev-d42f8d0.0+d42f8d0",
+    "@agoric/internal": "0.3.1-dev-d42f8d0.0+d42f8d0",
+    "@agoric/smart-wallet": "0.5.1-dev-d42f8d0.0+d42f8d0",
+    "@agoric/store": "0.9.1-dev-d42f8d0.0+d42f8d0",
+    "@agoric/swingset-vat": "0.32.1-dev-d42f8d0.0+d42f8d0",
+    "@agoric/vats": "0.14.1-dev-d42f8d0.0+d42f8d0",
+    "@agoric/zoe": "0.26.1-dev-d42f8d0.0+d42f8d0",
+    "@agoric/zone": "0.2.1-dev-d42f8d0.0+d42f8d0",
     "@confio/relayer": "^0.9.0",
     "@cosmjs/crypto": "^0.30.1",
     "@cosmjs/encoding": "^0.30.1",
@@ -88,5 +88,5 @@
     "timeout": "2m",
     "workerThreads": false
   },
-  "gitHead": "acefd94c2191c7fad2ebcb3f31f3d960582fc111"
+  "gitHead": "d42f8d099cb6457d27a5d04e3c91797948040502"
 }

package/src/commands/oracle.js

@@ -2,14 +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;
@@ -17,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
 
@@ -40,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]) => {
@@ -55,7 +86,7 @@ export const makeOracleCommand = logger => {
       return instance;
     };
 
-    return { ...utils, lookupPriceAggregatorInstance };
+    return { ...utils, networkConfig, lookupPriceAggregatorInstance };
   };
 
   oracle
@@ -96,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')
@@ -162,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
@@ -205,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;
 };