agoric 0.18.4 → 0.18.5-dev-800c2bb.0

package/src/commands/psm.js

@@ -4,13 +4,10 @@
 /* eslint-disable func-names */
 /* global fetch, process */
 import { Command } from 'commander';
+import { Offers } from '@agoric/inter-protocol/src/clientSupport.js';
 import { asPercent } from '../lib/format.js';
-import { makePSMSpendAction } from '../lib/psm.js';
-import {
-  makeRpcUtils,
-  boardSlottingMarshaller,
-  storageHelper,
-} from '../lib/rpc.js';
+import { makeRpcUtils, storageHelper } from '../lib/rpc.js';
+import { outputExecuteOfferAction } from '../lib/wallet.js';
 
 // Adapted from https://gist.github.com/dckc/8b5b2f16395cb4d7f2ff340e0bc6b610#file-psm-tool
 
@@ -33,35 +30,15 @@ function collectValues(val, memo) {
   return memo;
 }
 
-const { vstorage, fromBoard, agoricNames } = await makeRpcUtils({ fetch });
-
 /**
- *
- * @param {[Minted: string, Anchor: string]} pair
- */
-const getGovernanceState = async ([Minted, Anchor]) => {
-  const govContent = await vstorage.readLatest(
-    `published.psm.${Minted}.${Anchor}.governance`,
-  );
-  assert(govContent, 'no gov content');
-  const { current: governance } = last(
-    storageHelper.unserializeTxt(govContent, fromBoard),
-  );
-  const { [`psm.${Minted}.${Anchor}`]: instance } = agoricNames.instance;
-
-  return { instance, governance };
-};
-
-/**
- *
  * @param {import('anylogger').Logger} logger
  */
-export const makePsmCommand = async logger => {
+export const makePsmCommand = logger => {
   const psm = new Command('psm').description('PSM commands').usage(
     `
   WALLET=my-wallet
   export AGORIC_NET=ollinet
-  
+
   # provision wallet if necessary
   agd keys add $WALLET
   # provision with faucet, e.g.
@@ -74,7 +51,7 @@ export const makePsmCommand = async logger => {
   # prepare an offer to send
   # (offerId is optional but best to specify as each must be higher than the last and the default value is a huge number)
   agops psm swap --wantMinted 6 --feePct 0.01 --offerId 12 > offer-12.json
-  
+
   # watch for results in one terminal
   agoric wallet watch --from $WALLET
 
@@ -84,28 +61,45 @@ export const makePsmCommand = async logger => {
   `,
   );
 
-  const marshaller = boardSlottingMarshaller();
+  const rpcTools = async () => {
+    const utils = await makeRpcUtils({ fetch });
 
-  const lookupPsmInstance = ([minted, anchor]) => {
-    const name = `psm-${minted}-${anchor}`;
-    const instance = agoricNames.instance[name];
-    if (!instance) {
-      logger.debug('known instances:', agoricNames.instance);
-      throw new Error(`Unknown instance ${name}`);
-    }
-    return instance;
-  };
+    const lookupPsmInstance = ([minted, anchor]) => {
+      const name = `psm-${minted}-${anchor}`;
+      const instance = utils.agoricNames.instance[name];
+      if (!instance) {
+        logger.debug('known instances:', utils.agoricNames.instance);
+        throw Error(`Unknown instance ${name}`);
+      }
+      return instance;
+    };
+
+    /**
+     *
+     * @param {[Minted: string, Anchor: string]} pair
+     */
+    const getGovernanceState = async ([Minted, Anchor]) => {
+      const govContent = await utils.vstorage.readLatest(
+        `published.psm.${Minted}.${Anchor}.governance`,
+      );
+      assert(govContent, 'no gov content');
+      const { current: governance } = last(
+        storageHelper.unserializeTxt(govContent, utils.fromBoard),
+      );
+      const { [`psm.${Minted}.${Anchor}`]: instance } =
+        utils.agoricNames.instance;
 
-  /** @param {import('../lib/psm.js').BridgeAction} bridgeAction */
-  const outputAction = bridgeAction => {
-    const capData = marshaller.serialize(bridgeAction);
-    process.stdout.write(JSON.stringify(capData));
+      return { instance, governance };
+    };
+
+    return { ...utils, lookupPsmInstance, getGovernanceState };
   };
 
   psm
     .command('list')
     .description('list all PSMs in network')
     .action(async function () {
+      const { vstorage } = await rpcTools();
       const mints = await vstorage.keys('published.psm');
       for (const minted of mints) {
         const anchors = await vstorage.keys(`published.psm.${minted}`);
@@ -125,8 +119,9 @@ export const makePsmCommand = async logger => {
       s => s.split('.'),
       ['IST', 'AUSD'],
     )
-    .action(async function () {
-      const { pair } = this.opts();
+    .action(async function (opts) {
+      const { pair } = opts;
+      const { getGovernanceState } = await rpcTools();
       const { governance } = await getGovernanceState(pair);
       console.log('psm governance params', Object.keys(governance));
       console.log('MintLimit', governance.MintLimit.value);
@@ -154,83 +149,29 @@ export const makePsmCommand = async logger => {
     )
     // wantMinted and giveMinted options conflict.
     // TODO use .conflicts() after https://github.com/Agoric/agoric-sdk/issues/6181
-    .option('--wantMinted [DOLLARS]', 'amount of anchor tokens to give', Number)
-    .option('--giveMinted [DOLLARS]', 'amount of minted tokens to give', Number)
+    .option('--wantMinted <DOLLARS>', 'amount of anchor tokens to give', Number)
+    .option('--giveMinted <DOLLARS>', 'amount of minted tokens to give', Number)
     .option('--feePct [%]', 'Gas fee percentage', Number)
-    .option('--offerId [number]', 'Offer id', Number, Date.now())
-    .action(async function () {
-      const opts = this.opts();
+    .option('--offerId <string>', 'Offer id', String, `swap-${Date.now()}`)
+    .action(async function (
+      /** @type {Parameters<typeof Offers.psm.swap>[2]} */ opts,
+    ) {
       console.warn('running with options', opts);
+      const { agoricNames, lookupPsmInstance } = await rpcTools();
       const instance = await lookupPsmInstance(opts.pair);
-      // @ts-expect-error xxx RpcRemote
-      const spendAction = makePSMSpendAction(instance, agoricNames.brand, opts);
-      outputAction(spendAction);
-    });
-
-  psm
-    .command('committee')
-    .description('join the economic committee')
-    .option('--offerId [number]', 'Offer id', Number, Date.now())
-    .action(async function () {
-      const opts = this.opts();
-
-      const { economicCommittee } = agoricNames.instance;
-      assert(economicCommittee, 'missing economicCommittee');
-
-      /** @type {import('../lib/psm.js').OfferSpec} */
-      const offer = {
-        id: Number(opts.offerId),
-        invitationSpec: {
-          source: 'purse',
-          // @ts-expect-error xxx RpcRemote
-          instance: economicCommittee,
-          description: 'Voter0', // XXX it may not always be
-        },
-        proposal: {},
-      };
-
-      outputAction({
-        method: 'executeOffer',
-        offer,
-      });
-
-      console.warn('Now execute the prepared offer');
-    });
-
-  psm
-    .command('charter')
-    .description('prepare an offer to accept the charter invitation')
-    .option('--offerId [number]', 'Offer id', Number, Date.now())
-    .action(async function () {
-      const opts = this.opts();
-
-      const { psmCharter } = agoricNames.instance;
-      assert(psmCharter, 'missing psmCharter');
-
-      /** @type {import('../lib/psm.js').OfferSpec} */
-      const offer = {
-        id: Number(opts.offerId),
-        invitationSpec: {
-          source: 'purse',
-          // @ts-expect-error xxx RpcRemote
-          instance: psmCharter,
-          description: 'PSM charter member invitation',
-        },
-        proposal: {},
-      };
-
-      outputAction({
-        method: 'executeOffer',
-        offer,
-      });
-
-      console.warn('Now execute the prepared offer');
+      const offer = Offers.psm.swap(instance, agoricNames.brand, opts);
+      outputExecuteOfferAction(offer);
     });
 
   psm
     .command('proposePauseOffers')
     .description('propose a vote')
-    .option('--offerId [number]', 'Offer id', Number, Date.now())
+    .option(
+      '--offerId <string>',
+      'Offer id',
+      String,
+      `proposePauseOffers-${Date.now()}`,
+    )
     .requiredOption(
       '--pair [Minted.Anchor]',
       'token pair (Minted.Anchor)',
@@ -238,33 +179,31 @@ export const makePsmCommand = async logger => {
       ['IST', 'AUSD'],
     )
     .requiredOption(
-      '--psmCharterAcceptOfferId [number]',
+      '--charterAcceptOfferId <string>',
       'offer that had continuing invitation result',
-      Number,
     )
     .requiredOption(
-      '--substring [string]',
+      '--substring <string>',
       'an offer string to pause (can be repeated)',
       collectValues,
       [],
     )
     .option(
-      '--deadline [minutes]',
+      '--deadline <minutes>',
       'minutes from now to close the vote',
       Number,
       1,
     )
-    .action(async function () {
-      const opts = this.opts();
-
+    .action(async function (opts) {
+      const { lookupPsmInstance } = await rpcTools();
       const psmInstance = lookupPsmInstance(opts.pair);
 
-      /** @type {import('../lib/psm.js').OfferSpec} */
+      /** @type {import('@agoric/smart-wallet/src/offers.js').OfferSpec} */
       const offer = {
-        id: Number(opts.offerId),
+        id: opts.offerId,
         invitationSpec: {
           source: 'continuing',
-          previousOffer: opts.psmCharterAcceptOfferId,
+          previousOffer: opts.charterAcceptOfferId,
           invitationMakerName: 'VoteOnPauseOffers',
           // ( instance, strings list, timer deadline seconds )
           invitationArgs: harden([
@@ -276,10 +215,7 @@ export const makePsmCommand = async logger => {
         proposal: {},
       };
 
-      outputAction({
-        method: 'executeOffer',
-        offer,
-      });
+      outputExecuteOfferAction(offer);
 
       console.warn('Now execute the prepared offer');
     });
@@ -288,10 +224,10 @@ export const makePsmCommand = async logger => {
     .command('proposeChangeMintLimit')
     .description('propose to change the MintLimit parameter')
     .option(
-      '--offerId [number]',
+      '--offerId <string>',
       'id of this offer (optional)',
-      Number,
-      Date.now(),
+      String,
+      `proposeChangeMintLimit-${Date.now()}`,
     )
     .requiredOption(
       '--pair [Minted.Anchor]',
@@ -300,20 +236,18 @@ export const makePsmCommand = async logger => {
       ['IST', 'AUSD'],
     )
     .requiredOption(
-      '--previousOfferId [number]',
+      '--previousOfferId <string>',
       'offer using psm charter invitation',
-      Number,
     )
-    .requiredOption('--limit [number]', 'new mint limit (in IST)', Number)
+    .requiredOption('--limit <number>', 'new mint limit (in IST)', Number)
     .option(
-      '--deadline [minutes]',
+      '--deadline <minutes>',
       'minutes from now to close the vote',
       Number,
       1,
     )
-    .action(async function () {
-      const opts = this.opts();
-
+    .action(async function (opts) {
+      const { agoricNames, lookupPsmInstance } = await rpcTools();
       const psmInstance = lookupPsmInstance(opts.pair);
 
       const istBrand = agoricNames.brand.IST;
@@ -321,9 +255,9 @@ export const makePsmCommand = async logger => {
         brand: istBrand,
         value: BigInt(opts.limit * 1_000_000),
       });
-      /** @type {import('../lib/psm.js').OfferSpec} */
+      /** @type {import('@agoric/smart-wallet/src/offers.js').OfferSpec} */
       const offer = {
-        id: Number(opts.offerId),
+        id: opts.offerId,
         invitationSpec: {
           source: 'continuing',
           previousOffer: opts.previousOfferId,
@@ -337,76 +271,7 @@ export const makePsmCommand = async logger => {
         },
       };
 
-      outputAction({
-        method: 'executeOffer',
-        offer,
-      });
-
-      console.warn('Now execute the prepared offer');
-    });
-
-  psm
-    .command('vote')
-    .description('vote on a question (hard-coded for now))')
-    .option('--offerId [number]', 'Offer id', Number, Date.now())
-    .requiredOption(
-      '--econCommAcceptOfferId [number]',
-      'offer that had continuing invitation result',
-      Number,
-    )
-    .requiredOption(
-      '--pair [Minted.Anchor]',
-      'token pair (Minted.Anchor)',
-      s => s.split('.'),
-      ['IST', 'AUSD'],
-    )
-    .requiredOption(
-      '--forPosition [number]',
-      'index of one position to vote for (within the question description.positions); ',
-      Number,
-    )
-    .action(async function () {
-      const opts = this.opts();
-
-      const questionHandleCapDataStr = await vstorage.readLatest(
-        'published.committees.Economic_Committee.latestQuestion',
-      );
-      const questionDescriptions = storageHelper.unserializeTxt(
-        questionHandleCapDataStr,
-        fromBoard,
-      );
-
-      assert(questionDescriptions, 'missing questionDescriptions');
-      assert(
-        questionDescriptions.length === 1,
-        'multiple questions not supported',
-      );
-
-      const questionDesc = questionDescriptions[0];
-      // TODO support multiple position arguments
-      const chosenPositions = [questionDesc.positions[opts.forPosition]];
-      assert(chosenPositions, `undefined position index ${opts.forPosition}`);
-
-      /** @type {import('../lib/psm.js').OfferSpec} */
-      const offer = {
-        id: Number(opts.offerId),
-        invitationSpec: {
-          source: 'continuing',
-          previousOffer: opts.previousOfferId,
-          invitationMakerName: 'makeVoteInvitation',
-          // (positionList, questionHandle)
-          invitationArgs: harden([
-            chosenPositions,
-            questionDesc.questionHandle,
-          ]),
-        },
-        proposal: {},
-      };
-
-      outputAction({
-        method: 'executeOffer',
-        offer,
-      });
+      outputExecuteOfferAction(offer);
 
       console.warn('Now execute the prepared offer');
     });

package/src/commands/reserve.js

@@ -0,0 +1,98 @@
+/* eslint-disable @jessie.js/no-nested-await */
+// @ts-check
+/* eslint-disable func-names */
+/* global fetch, process */
+import { Offers } from '@agoric/inter-protocol/src/clientSupport.js';
+import { Command } from 'commander';
+import { makeRpcUtils } from '../lib/rpc.js';
+import { outputActionAndHint } from '../lib/wallet.js';
+
+/**
+ * @param {import('anylogger').Logger} _logger
+ * @param {*} io
+ */
+export const makeReserveCommand = (_logger, io = {}) => {
+  const { stdout = process.stdout, stderr = process.stderr, now } = io;
+  const reserve = new Command('reserve').description('Asset Reserve commands');
+
+  reserve
+    .command('add')
+    .description('add collateral to the reserve')
+    .requiredOption('--give <number>', 'Collateral to give', Number)
+    .option('--collateral-brand <string>', 'Collateral brand key', 'ATOM')
+    .option('--offer-id <string>', 'Offer id', String, `addCollateral-${now()}`)
+    .action(
+      /**
+       * @param {{
+       *   give: number,
+       *   collateralBrand: string,
+       *   offerId: string,
+       * }} opts
+       */
+      async ({ collateralBrand, ...opts }) => {
+        const { agoricNames } = await makeRpcUtils({ fetch });
+
+        const offer = Offers.reserve.AddCollateral(agoricNames.brand, {
+          collateralBrandKey: collateralBrand,
+          ...opts,
+        });
+        outputActionAndHint(
+          { method: 'executeOffer', offer },
+          { stdout, stderr },
+        );
+      },
+    );
+
+  reserve
+    .command('proposeBurn')
+    .description('propose a call to burnFeesToReduceShortfall')
+    .option(
+      '--offerId <string>',
+      'Offer id',
+      String,
+      `proposePauseOffers-${Date.now()}`,
+    )
+    .requiredOption(
+      '--charterAcceptOfferId <string>',
+      'offer that had continuing invitation result',
+    )
+    .requiredOption('--value [integer]', 'value of µIST to burn', BigInt)
+    .option(
+      '--deadline <minutes>',
+      'minutes from now to close the vote',
+      Number,
+      1,
+    )
+    .action(async function (opts) {
+      const { agoricNames } = await makeRpcUtils({ fetch });
+
+      const reserveInstance = agoricNames.instance.reserve;
+      assert(reserveInstance, 'missing reserve in names');
+
+      const feesToBurn = { brand: agoricNames.brand.IST, value: opts.value };
+
+      /** @type {import('@agoric/smart-wallet/src/offers.js').OfferSpec} */
+      const offer = {
+        id: opts.offerId,
+        invitationSpec: {
+          source: 'continuing',
+          previousOffer: opts.charterAcceptOfferId,
+          invitationMakerName: 'VoteOnApiCall',
+          invitationArgs: harden([
+            reserveInstance,
+            'burnFeesToReduceShortfall',
+            [feesToBurn],
+            BigInt(opts.deadline * 60 + Math.round(Date.now() / 1000)),
+          ]),
+        },
+        proposal: {},
+      };
+
+      outputActionAndHint(
+        { method: 'executeOffer', offer },
+        { stdout, stderr },
+      );
+    });
+
+  return reserve;
+};

package/src/commands/test-upgrade.js

@@ -0,0 +1,109 @@
+// @ts-check
+/* global process */
+import { Fail } from '@agoric/assert';
+import { CommanderError } from 'commander';
+import { normalizeAddressWithOptions } from '../lib/chain.js';
+import { bigintReplacer } from '../lib/format.js';
+import { getNetworkConfig } from '../lib/rpc.js';
+import { makeWalletUtils, sendAction } from '../lib/wallet.js';
+
+/**
+ * Make commands for testing.
+ *
+ * @param {{
+ *   env: Partial<Record<string, string>>,
+ *   stdout: Pick<import('stream').Writable,'write'>,
+ *   stderr: Pick<import('stream').Writable,'write'>,
+ *   now: () => number,
+ *   createCommand: // Note: includes access to process.stdout, .stderr, .exit
+ *     typeof import('commander').createCommand,
+ *   execFileSync: typeof import('child_process').execFileSync,
+ *   setTimeout: typeof setTimeout,
+ * }} process
+ * @param {{ fetch: typeof window.fetch }} net
+ */
+export const makeTestCommand = (
+  { env, stdout, now, setTimeout, execFileSync, createCommand },
+  { fetch },
+) => {
+  /** @param {number} ms */
+  const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+  const show = (info, indent = false) =>
+    stdout.write(
+      `${JSON.stringify(info, bigintReplacer, indent ? 2 : undefined)}\n`,
+    );
+
+  const tryMakeUtils = async () => {
+    await null;
+    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);
+    } catch (err) {
+      throw new CommanderError(1, 'RPC_FAIL', err.message);
+    }
+  };
+
+  const testCmd = createCommand('test').description('test operations');
+
+  testCmd
+    .command('upgrade-contract')
+    .description('make simple offer to upgrade-contract')
+    .option('--home <dir>', 'agd CosmosSDK application home directory')
+    .option(
+      '--keyring-backend <os|file|test>',
+      `keyring's backend (os|file|test) (default "${
+        env.AGORIC_KEYRING_BACKEND || 'os'
+      }")`,
+      env.AGORIC_KEYRING_BACKEND,
+    )
+    .option('--offer-id <string>', 'Offer id', String, `my-${now()}`)
+    .requiredOption(
+      '--from <address>',
+      'wallet address literal or name',
+      literalOrName =>
+        normalizeAddressWithOptions(literalOrName, testCmd.opts(), {
+          execFileSync,
+        }),
+    )
+    .action(async opts => {
+      const { agoricNames, networkConfig, pollOffer } = await tryMakeUtils();
+      const { from } = opts;
+      const { home, keyringBackend: backend } = testCmd.opts();
+
+      const io = { ...networkConfig, execFileSync, delay, stdout };
+      /** @type {import('@agoric/smart-wallet/src/offers.js').OfferSpec} */
+      const offer = {
+        id: opts.offerId,
+        invitationSpec: {
+          source: 'contract',
+          instance: agoricNames.instance.myInstance || Fail`no myInstance`,
+          publicInvitationMaker: 'makeInvitation',
+        },
+        proposal: {
+          want: { Tokens: { brand: agoricNames.brand.GoodStuff, value: 32n } },
+        },
+      };
+      const result = await sendAction(
+        {
+          method: 'executeOffer',
+          offer,
+        },
+        { keyring: { home, backend }, from, verbose: false, ...io },
+      );
+      if (result?.code !== 0) {
+        throw result;
+      }
+      show({ height: result?.height, txhash: result?.txhash });
+      const found = await pollOffer(from, offer.id, result.height, true);
+      show(found, true);
+      const numWantsSatisfied = found.numWantsSatisfied || 0;
+      if (numWantsSatisfied < 1) {
+        process.exit(2);
+      }
+    });
+
+  return testCmd;
+};