agoric 0.21.2-other-dev-8f8782b.0 → 0.21.2-other-dev-fbe72e7.0.fbe72e7

package/src/commands/inter.js

@@ -4,32 +4,19 @@
  */
 
 // @ts-check
-import { CommanderError, InvalidArgumentError } from 'commander';
-// TODO: should get M from endo https://github.com/Agoric/agoric-sdk/issues/7090
+import { fetchEnvNetworkConfig, makeWalletUtils } from '@agoric/client-utils';
 import { makeOfferSpecShape } from '@agoric/inter-protocol/src/auction/auctionBook.js';
 import { Offers } from '@agoric/inter-protocol/src/clientSupport.js';
 import { objectMap } from '@agoric/internal';
-import { M, matches } from '@agoric/store';
-
-// XXX scare away ambient type zombies to fix ScheduleNotification.activeStartTime etc.
-// https://github.com/Agoric/agoric-sdk/issues/6512
-// https://github.com/Agoric/agoric-sdk/issues/6343
-import '@agoric/inter-protocol/src/vaultFactory/types.js';
-
+import { M, matches } from '@endo/patterns';
+import { CommanderError, InvalidArgumentError } from 'commander';
 import { normalizeAddressWithOptions, pollBlocks } from '../lib/chain.js';
 import {
   asBoardRemote,
   bigintReplacer,
   makeAmountFormatter,
 } from '../lib/format.js';
-import { getNetworkConfig } from '../lib/rpc.js';
-import {
-  getCurrent,
-  makeParseAmount,
-  makeWalletUtils,
-  outputActionAndHint,
-  sendAction,
-} from '../lib/wallet.js';
+import { getCurrent, outputActionAndHint, sendAction } from '../lib/wallet.js';
 
 const { values } = Object;
 
@@ -39,16 +26,16 @@ const bidInvitationShape = harden({
   callPipe: [['makeBidInvitation', M.any()]],
 });
 
-/** @typedef {import('@agoric/vats/tools/board-utils.js').VBankAssetDetail } AssetDescriptor */
-/** @typedef {import('@agoric/smart-wallet/src/smartWallet').TryExitOfferAction } TryExitOfferAction */
-/** @typedef {import('@agoric/inter-protocol/src/auction/auctionBook.js').OfferSpec}  BidSpec */
-/** @typedef {import('@agoric/inter-protocol/src/auction/scheduler.js').ScheduleNotification} ScheduleNotification */
-/** @typedef {import('@agoric/inter-protocol/src/auction/auctionBook.js').BookDataNotification} BookDataNotification */
+/** @import {VBankAssetDetail} from '@agoric/vats/tools/board-utils.js'; */
+/** @import {TryExitOfferAction} from '@agoric/smart-wallet/src/smartWallet.js'; */
+/** @import {OfferSpec as BidSpec} from '@agoric/inter-protocol/src/auction/auctionBook.js' */
+/** @import {ScheduleNotification} from '@agoric/inter-protocol/src/auction/scheduler.js' */
+/** @import {BookDataNotification} from '@agoric/inter-protocol/src/auction/auctionBook.js' */
 
 /**
  * Format amounts, prices etc. based on brand board Ids, displayInfo
  *
- * @param {AssetDescriptor[]} assets
+ * @param {VBankAssetDetail[]} assets
  */
 const makeFormatters = assets => {
   const r4 = x => Math.round(x * 10_000) / 10_000;
@@ -71,12 +58,12 @@ const makeFormatters = assets => {
     r4(100 - (Number(r.numerator.value) / Number(r.denominator.value)) * 100);
 
   // XXX real TimeMath.absValue requires real Remotable timerBrand
-  /** @param {import('@agoric/time/src/types.js').Timestamp} ts */
+  /** @param {import('@agoric/time').Timestamp} ts */
   const absValue = ts => (typeof ts === 'bigint' ? ts : ts.absValue);
 
-  /** @param {import('@agoric/time/src/types.js').Timestamp} tr */
+  /** @param {import('@agoric/time').Timestamp} tr */
   const absTime = tr => new Date(Number(absValue(tr)) * 1000).toISOString();
-  /** @param {import('@agoric/time/src/types.js').RelativeTimeRecord} tr */
+  /** @param {import('@agoric/time').RelativeTimeRecord} tr */
   const relTime = tr =>
     new Date(Number(tr.relValue) * 1000).toISOString().slice(11, 19);
 
@@ -88,7 +75,7 @@ const makeFormatters = assets => {
    * @param {(_: T) => string} f
    * @returns { (x: T | null | undefined ) => string | undefined }
    */
-  const maybe = f => x => x ? f(x) : undefined;
+  const maybe = f => x => (x ? f(x) : undefined);
 
   return {
     amount,
@@ -108,7 +95,7 @@ const makeFormatters = assets => {
  * Dynamic check that an OfferStatus is also a BidSpec.
  *
  * @param {import('@agoric/smart-wallet/src/offers.js').OfferStatus} offerStatus
- * @param {Awaited<ReturnType<import('../lib/rpc').makeAgoricNames>>} agoricNames
+ * @param {import('@agoric/vats/tools/board-utils.js').AgoricNamesRemotes} agoricNames
  * @param {typeof console.warn} warn
  * returns null if offerStatus is not a BidSpec
  */
@@ -144,7 +131,7 @@ const coerceBid = (offerStatus, agoricNames, warn) => {
  *
  * @param {import('@agoric/smart-wallet/src/offers.js').OfferStatus &
  *         { offerArgs: BidSpec}} bid
- * @param {import('agoric/src/lib/format.js').AssetDescriptor[]} assets
+ * @param {VBankAssetDetail[]} assets
  */
 export const fmtBid = (bid, assets) => {
   const fmt = makeFormatters(assets);
@@ -206,6 +193,10 @@ export const makeInterCommand = (
   const interCmd = createCommand('inter')
     .description('Inter Protocol commands for liquidation bidding etc.')
     .option('--home <dir>', 'agd CosmosSDK application home directory')
+    .option(
+      '--fees <amount>',
+      'set fees for transaction broadcast (e.g. 5000ubld)',
+    )
     .option(
       '--keyring-backend <os|file|test>',
       `keyring's backend (os|file|test) (default "${
@@ -220,6 +211,8 @@ export const makeInterCommand = (
     try {
       return rawExec(file, args, ...opts);
     } catch (err) {
+      // InvalidArgumentError is a class constructor, and so
+      // must be invoked with `new`.
       throw new InvalidArgumentError(
         `${err.message}: is ${file} in your $PATH?`,
       );
@@ -238,10 +231,11 @@ export const makeInterCommand = (
     try {
       // XXX pass fetch to getNetworkConfig() explicitly
       // await null above makes this await safe
-      // eslint-disable-next-line @jessie.js/no-nested-await
-      const networkConfig = await getNetworkConfig(env);
-      return makeWalletUtils({ fetch, execFileSync, delay }, networkConfig);
+      const networkConfig = await fetchEnvNetworkConfig({ env, fetch });
+      return makeWalletUtils({ fetch, delay }, networkConfig);
     } catch (err) {
+      // CommanderError is a class constructor, and so
+      // must be invoked with `new`.
       throw new CommanderError(1, 'RPC_FAIL', err.message);
     }
   };
@@ -286,14 +280,12 @@ inter auction status
          * }}
          */ opts,
       ) => {
-        const { agoricNames, readLatestHead } = await tryMakeUtils();
+        const { agoricNames, readPublished } = await tryMakeUtils();
 
-        /** @type { [ScheduleNotification, BookDataNotification, *] } */
-        // @ts-expect-error dynamic cast
         const [schedule, book, { current: params }] = await Promise.all([
-          readLatestHead(`published.auction.schedule`),
-          readLatestHead(`published.auction.book${opts.book}`),
-          readLatestHead(`published.auction.governance`),
+          readPublished('auction.schedule'),
+          readPublished(`auction.book${opts.book}`),
+          readPublished('auction.governance'),
         ]);
 
         const fmt = makeFormatters(Object.values(agoricNames.vbankAsset));
@@ -333,16 +325,16 @@ inter auction status
    * @param {string} from
    * @param {import('@agoric/smart-wallet/src/offers.js').OfferSpec} offer
    * @param {Awaited<ReturnType<tryMakeUtils>>} tools
-   * @param {boolean?} dryRun
+   * @param {boolean | undefined} dryRun
    */
   const placeBid = async (from, offer, tools, dryRun = false) => {
     const { networkConfig, agoricNames, pollOffer } = tools;
     const io = { ...networkConfig, execFileSync, delay, stdout };
 
-    const { home, keyringBackend: backend } = interCmd.opts();
+    const { home, keyringBackend: backend, fees } = interCmd.opts();
     const result = await sendAction(
       { method: 'executeOffer', offer },
-      { keyring: { home, backend }, from, verbose: false, dryRun, ...io },
+      { keyring: { home, backend }, from, fees, verbose: false, dryRun, ...io },
     );
     if (dryRun) {
       return;
@@ -416,14 +408,7 @@ inter auction status
       async ({ generateOnly, dryRun, ...opts }) => {
         const tools = await tryMakeUtils();
 
-        const parseAmount = makeParseAmount(
-          tools.agoricNames,
-          msg => new InvalidArgumentError(msg),
-        );
-        const offer = Offers.auction.Bid(tools.agoricNames.brand, {
-          ...opts,
-          parseAmount,
-        });
+        const offer = Offers.auction.Bid(tools.agoricNames, opts);
 
         if (generateOnly) {
           outputActionAndHint(
@@ -441,6 +426,8 @@ inter auction status
   const parsePercent = v => {
     const p = Number(v);
     if (!(p >= -100 && p <= 100)) {
+      // InvalidArgumentError is a class constructor, and so
+      // must be invoked with `new`.
       throw new InvalidArgumentError('must be between -100 and 100');
     }
     return p / 100;
@@ -464,14 +451,7 @@ inter auction status
       async ({ generateOnly, ...opts }) => {
         const tools = await tryMakeUtils();
 
-        const parseAmount = makeParseAmount(
-          tools.agoricNames,
-          msg => new InvalidArgumentError(msg),
-        );
-        const offer = Offers.auction.Bid(tools.agoricNames.brand, {
-          ...opts,
-          parseAmount,
-        });
+        const offer = Offers.auction.Bid(tools.agoricNames, opts);
         if (generateOnly) {
           outputActionAndHint(
             { method: 'executeOffer', offer },
@@ -510,11 +490,13 @@ inter auction status
           return;
         }
 
-        const { networkConfig, readLatestHead } = await tryMakeUtils();
+        const { networkConfig, readPublished } = await tryMakeUtils();
 
-        const current = await getCurrent(from, { readLatestHead });
+        const current = await getCurrent(from, { readPublished });
         const liveIds = current.liveOffers.map(([i, _s]) => i);
         if (!liveIds.includes(id)) {
+          // InvalidArgumentError is a class constructor, and so
+          // must be invoked with `new`.
           throw new InvalidArgumentError(
             `${id} not in live offer ids: ${liveIds}`,
           );
@@ -535,7 +517,7 @@ inter auction status
         show({ timestamp, height, offerId: id, txhash });
 
         const checkGone = async blockInfo => {
-          const pollResult = await getCurrent(from, { readLatestHead });
+          const pollResult = await getCurrent(from, { readPublished });
           const found = pollResult.liveOffers.find(([i, _]) => i === id);
           if (found) throw Error('retry');
           return blockInfo;
@@ -577,11 +559,11 @@ $ inter bid list --from my-acct
        * }} opts
        */
       async opts => {
-        const { agoricNames, readLatestHead, storedWalletState } =
+        const { agoricNames, readPublished, storedWalletState } =
           await tryMakeUtils();
 
         const [current, state] = await Promise.all([
-          getCurrent(opts.from, { readLatestHead }),
+          getCurrent(opts.from, { readPublished }),
           storedWalletState(opts.from),
         ]);
         const entries = opts.all

package/src/commands/oracle.js

@@ -1,44 +1,59 @@
-/* eslint-disable no-await-in-loop */
-/* eslint-disable @jessie.js/no-nested-await */
 // @ts-check
 /* eslint-disable func-names */
-/* global fetch, setTimeout, process */
-import { Fail } from '@agoric/assert';
+/* eslint-env node */
+import {
+  fetchEnvNetworkConfig,
+  makeAgoricNames,
+  makeVstorageKit,
+  makeWalletUtils,
+  storageHelper,
+} from '@agoric/client-utils';
 import { Offers } from '@agoric/inter-protocol/src/clientSupport.js';
+import { oracleBrandFeedName } from '@agoric/inter-protocol/src/proposals/utils.js';
+import { Fail } from '@endo/errors';
 import { Nat } from '@endo/nat';
 import { Command } from 'commander';
-import * as cp from 'child_process';
 import { inspect } from 'util';
 import { normalizeAddressWithOptions } from '../lib/chain.js';
-import { getNetworkConfig, makeRpcUtils, storageHelper } from '../lib/rpc.js';
+import { bigintReplacer } from '../lib/format.js';
 import {
   getCurrent,
-  makeWalletUtils,
   outputAction,
   sendAction,
+  sendHint,
 } from '../lib/wallet.js';
-import { bigintReplacer } from '../lib/format.js';
+
+/** @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js'; */
 
 // XXX support other decimal places
 const COSMOS_UNIT = 1_000_000n;
-const scaleDecimals = num => BigInt(num * Number(COSMOS_UNIT));
+/** @param {number} num */
+const scaleDecimals = num => BigInt(Math.round(num * Number(COSMOS_UNIT)));
 
 /**
- * @param {import('anylogger').Logger} logger
+ * Prints JSON output to stdout and diagnostic info (like logs) to stderr
+ *
  * @param {{
- *   delay?: (ms: number) => Promise<void>,
- *   execFileSync?: typeof import('child_process').execFileSync,
- *   env?: Record<string, string | undefined>,
- *   stdout?: Pick<import('stream').Writable,'write'>,
- * }} [io]
+ *   createCommand: typeof import('commander').createCommand,
+ *   env: Partial<Record<string, string>>,
+ *   execFileSync: typeof import('child_process').execFileSync,
+ *   now: () => number,
+ *   setTimeout: typeof setTimeout,
+ *   stderr: Pick<import('stream').Writable,'write'>,
+ *   stdout: Pick<import('stream').Writable,'write'>,
+ * }} process
+ * @param {import('anylogger').Logger} [logger]
  */
-export const makeOracleCommand = (logger, io = {}) => {
-  const {
-    delay = ms => new Promise(resolve => setTimeout(resolve, ms)),
-    execFileSync = cp.execFileSync,
-    env = process.env,
-    stdout = process.stdout,
-  } = io;
+export const makeOracleCommand = (
+  { env, execFileSync, setTimeout, stderr, stdout },
+  logger,
+) => {
+  /**
+   * @param {number} ms
+   * @returns {Promise<void>}
+   */
+  const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+
   const oracle = new Command('oracle')
     .description('Oracle commands')
     .usage(
@@ -71,22 +86,31 @@ export const makeOracleCommand = (logger, io = {}) => {
       env.AGORIC_KEYRING_BACKEND,
     );
 
+  const normalizeAddress = literalOrName =>
+    normalizeAddressWithOptions(literalOrName, oracle.opts(), {
+      execFileSync,
+    });
+
   const rpcTools = async () => {
     // XXX pass fetch to getNetworkConfig() explicitly
-    const networkConfig = await getNetworkConfig(env);
-    const utils = await makeRpcUtils({ fetch });
+    const networkConfig = await fetchEnvNetworkConfig({
+      env: process.env,
+      fetch,
+    });
+    const vsk = makeVstorageKit({ fetch }, networkConfig);
+    const agoricNames = await makeAgoricNames(vsk.fromBoard, vsk.vstorage);
 
     const lookupPriceAggregatorInstance = ([brandIn, brandOut]) => {
-      const name = `${brandIn}-${brandOut} price feed`;
-      const instance = utils.agoricNames.instance[name];
+      const name = oracleBrandFeedName(brandIn, brandOut);
+      const instance = agoricNames.instance[name];
       if (!instance) {
-        logger.debug('known instances:', utils.agoricNames.instance);
+        logger && logger.debug('known instances:', agoricNames.instance);
         throw Error(`Unknown instance ${name}`);
       }
       return instance;
     };
 
-    return { ...utils, networkConfig, lookupPriceAggregatorInstance };
+    return { ...vsk, networkConfig, lookupPriceAggregatorInstance };
   };
 
   oracle
@@ -119,12 +143,15 @@ export const makeOracleCommand = (logger, io = {}) => {
         proposal: {},
       };
 
-      outputAction({
-        method: 'executeOffer',
-        offer,
-      });
+      outputAction(
+        {
+          method: 'executeOffer',
+          offer,
+        },
+        stdout,
+      );
 
-      console.warn('Now execute the prepared offer');
+      stderr.write(sendHint);
     });
 
   oracle
@@ -154,24 +181,27 @@ export const makeOracleCommand = (logger, io = {}) => {
         opts.oracleAdminAcceptOfferId,
       );
 
-      outputAction({
-        method: 'executeOffer',
-        offer,
-      });
+      outputAction(
+        {
+          method: 'executeOffer',
+          offer,
+        },
+        stdout,
+      );
 
-      console.warn('Now execute the prepared offer');
+      stderr.write(sendHint);
     });
 
-  const findOracleCap = async (from, readLatestHead) => {
-    const current = await getCurrent(from, { readLatestHead });
+  const findOracleCap = async (instance, from, readPublished) => {
+    const current = await getCurrent(from, { readPublished });
 
     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') {
+      const [{ description, instance: candidate }] = value;
+      if (description === 'oracle invitation' && candidate === instance) {
         return offerId;
       }
     }
@@ -180,11 +210,21 @@ export const makeOracleCommand = (logger, io = {}) => {
   oracle
     .command('find-continuing-id')
     .description('print id of specified oracle continuing invitation')
-    .requiredOption('--from <address>', 'from address', String)
+    .requiredOption(
+      '--from <address>',
+      'wallet address literal or name',
+      normalizeAddress,
+    )
+    .requiredOption(
+      '--pair [brandIn.brandOut]',
+      'token pair (brandIn.brandOut)',
+      s => s.split('.'),
+    )
     .action(async opts => {
-      const { readLatestHead } = await makeRpcUtils({ fetch });
+      const { readPublished, lookupPriceAggregatorInstance } = await rpcTools();
+      const instance = lookupPriceAggregatorInstance(opts.pair);
 
-      const offerId = await findOracleCap(opts.from, readLatestHead);
+      const offerId = await findOracleCap(instance, opts.from, readPublished);
       if (!offerId) {
         console.error('No continuing ids found');
       }
@@ -212,11 +252,6 @@ export const makeOracleCommand = (logger, io = {}) => {
       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`,
@@ -250,21 +285,22 @@ export const makeOracleCommand = (logger, io = {}) => {
          * }}
          */ { pair, keys, price },
       ) => {
-        const { readLatestHead, networkConfig } = await rpcTools();
-        const wutil = await makeWalletUtils(
-          { fetch, execFileSync, delay },
+        const {
+          readLatestHead,
+          readPublished,
           networkConfig,
-        );
+          lookupPriceAggregatorInstance,
+        } = await rpcTools();
+        const wutil = await makeWalletUtils({ fetch, delay }, networkConfig);
         const unitPrice = scaleDecimals(price);
 
-        console.error(`${pair[0]}-${pair[1]}_price_feed: before setPrice`);
+        const feedPath = `published.priceFeed.${pair[0]}-${pair[1]}_price_feed`;
 
         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);
+            readLatestHead(feedPath).catch(() => {
+              const viewer = `https://vstorage.agoric.net/#${networkConfig.rpcAddrs[0]}|published,published.priceFeed|${feedPath}`;
+              stderr.write(`no existing price data; see ${viewer}`);
               return undefined;
             })
           );
@@ -283,40 +319,61 @@ export const makeOracleCommand = (logger, io = {}) => {
           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);
-        });
+        if (before) {
+          console.error(
+            'Choose lead oracle operator order based on latestRound...',
+          );
 
-        console.error('pushPrice from each:', keyOrder);
+          const latestRoundP =
+            /** @type {Promise<{roundId: number, startedAt: import('@agoric/time').TimestampRecord, startedBy: string}>} */ (
+              readLatestHead(
+                `published.priceFeed.${pair[0]}-${pair[1]}_price_feed.latestRound`,
+              )
+            );
+          await Promise.race([
+            delay(5000),
+            latestRoundP.then(round => {
+              const { roundId, startedAt, startedBy } = round;
+              show({
+                startedAt: fmtSecs(startedAt.absValue),
+                roundId,
+                startedBy,
+              });
+              if (startedBy === keyOrder[0]) {
+                keyOrder.reverse();
+              }
+            }),
+          ]).catch(err => {
+            stderr.write(err);
+          });
+        }
+
+        const instance = lookupPriceAggregatorInstance(pair);
+        const adminOfferIds = {};
         for await (const from of keyOrder) {
-          const oracleAdminAcceptOfferId = await findOracleCap(
+          adminOfferIds[from] = await findOracleCap(
+            instance,
             from,
-            readLatestHead,
+            readPublished,
           );
-          if (!oracleAdminAcceptOfferId) {
-            throw Error(`no oracle invitation found: ${from}`);
+          if (!adminOfferIds[from]) {
+            console.error(
+              `Failed to find an offer accepting oracle invitation for ${from}. Accept and try again:`,
+            );
+            console.error(
+              `    agops oracle accept > accept.json; agoric wallet send --from ${from} --offer accept.json`,
+            );
           }
+        }
+        assert(
+          Object.values(adminOfferIds).every(x => x),
+          'Missing oracle admin offer ids',
+        );
+
+        console.error('pushPrice from each:', keyOrder);
+        for await (const from of keyOrder) {
+          const oracleAdminAcceptOfferId = adminOfferIds[from];
           show({ from, oracleAdminAcceptOfferId });
           const offerId = `pushPrice-${Date.now()}`;
           const offer = Offers.fluxAggregator.PushPrice(

package/src/commands/perf.js

@@ -1,29 +1,29 @@
-/* eslint-disable no-await-in-loop */
-/* eslint-disable @jessie.js/no-nested-await */
 // @ts-check
 /* eslint-disable func-names */
-/* global process */
+/* eslint-env node */
 import {
   iterateEach,
   makeCastingSpec,
   makeFollower,
   makeLeaderFromRpcAddresses,
 } from '@agoric/casting';
+import { fetchEnvNetworkConfig } from '@agoric/client-utils';
+import { slotToRemotable } from '@agoric/internal/src/storage-test-utils.js';
+import { boardSlottingMarshaller } from '@agoric/vats/tools/board-utils.js';
 import { Command } from 'commander';
 import fs from 'fs';
 import { exit } from 'process';
-import { slotToRemotable } from '@agoric/internal/src/storage-test-utils.js';
-import { boardSlottingMarshaller } from '@agoric/vats/tools/board-utils.js';
 import { makeLeaderOptions } from '../lib/casting.js';
 import {
   execSwingsetTransaction,
   normalizeAddressWithOptions,
 } from '../lib/chain.js';
-import { networkConfig } from '../lib/rpc.js';
 
 // tight for perf testing but less than this tends to hang.
 const SLEEP_SECONDS = 0.1;
 
+const networkConfig = await fetchEnvNetworkConfig({ env: process.env, fetch });
+
 /**
  * @param {import('anylogger').Logger} logger
  */
@@ -51,6 +51,7 @@ export const makePerfCommand = logger => {
       'address literal or name',
       normalizeAddress,
     )
+    .option('--verbose')
     .action(async function (opts) {
       const sharedOpts = perf.opts();
       logger.warn({ sharedOpts, opts });
@@ -63,15 +64,13 @@ export const makePerfCommand = logger => {
 
       const spec = `:published.wallet.${opts.from}`;
 
-      const leaderOptions = makeLeaderOptions({
-        sleep: SLEEP_SECONDS,
-        jitter: 0,
-        log: () => undefined,
-      });
-
       const leader = makeLeaderFromRpcAddresses(
         networkConfig.rpcAddrs,
-        leaderOptions,
+        makeLeaderOptions({
+          sleep: SLEEP_SECONDS,
+          jitter: 0,
+          log: console.warn,
+        }),
       );
 
       logger.warn('Following', spec);
@@ -86,9 +85,10 @@ export const makePerfCommand = logger => {
             if (status.error) {
               console.error(status.error);
               exit(1);
-            } else if (status.numWantsSatisfied)
+            } else if (status.numWantsSatisfied) {
               process.stdout.write(`satisfied: ${status.numWantsSatisfied}\n`);
-            exit(0);
+              exit(0);
+            }
           }
         }
       };
@@ -102,7 +102,11 @@ export const makePerfCommand = logger => {
       if (sharedOpts.home) {
         cmd.push(`--home=${sharedOpts.home}`);
       }
-      execSwingsetTransaction(cmd, { from: opts.from, ...networkConfig });
+      execSwingsetTransaction(cmd, {
+        from: opts.from,
+        verbose: opts.verbose,
+        ...networkConfig,
+      });
     });
 
   return perf;