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

package/src/commands/ec.js

@@ -1,314 +0,0 @@
-/* eslint-disable @jessie.js/no-nested-await */
-// @ts-check
-/* eslint-disable func-names */
-/* global globalThis, process, setTimeout */
-import { execFileSync as execFileSyncAmbient } from 'child_process';
-import { Command, CommanderError } from 'commander';
-import { normalizeAddressWithOptions, pollBlocks } from '../lib/chain.js';
-import { getNetworkConfig, makeRpcUtils } from '../lib/rpc.js';
-import {
-  findContinuingIds,
-  getCurrent,
-  getLastUpdate,
-  outputActionAndHint,
-  sendAction,
-} from '../lib/wallet.js';
-
-/** @typedef {import('@agoric/smart-wallet/src/offers.js').OfferSpec} OfferSpec */
-
-/**
- * @param {import('anylogger').Logger} _logger
- * @param {{
- *   env?: Record<string, string|undefined>,
- *   fetch?: typeof window.fetch,
- *   stdout?: Pick<import('stream').Writable, 'write'>,
- *   stderr?: Pick<import('stream').Writable, 'write'>,
- *   execFileSync?: typeof execFileSyncAmbient,
- *   delay?: (ms: number) => Promise<void>,
- * }} [io]
- */
-export const makeEconomicCommiteeCommand = (_logger, io = {}) => {
-  const {
-    // Allow caller to provide access explicitly, but
-    // default to conventional ambient IO facilities.
-    env = process.env,
-    stdout = process.stdout,
-    stderr = process.stderr,
-    fetch = globalThis.fetch,
-    execFileSync = execFileSyncAmbient,
-    delay = ms => new Promise(resolve => setTimeout(resolve, ms)),
-  } = io;
-
-  const ec = new Command('ec').description('Economic Committee commands');
-
-  /** @param {string} literalOrName */
-  const normalizeAddress = literalOrName =>
-    normalizeAddressWithOptions(literalOrName, { keyringBackend: 'test' });
-
-  /** @type {(info: unknown, indent?: unknown) => boolean } */
-  const show = (info, indent) =>
-    stdout.write(`${JSON.stringify(info, null, indent ? 2 : undefined)}\n`);
-
-  const abortIfSeen = (instanceName, found) => {
-    const done = found.filter(it => it.instanceName === instanceName);
-    if (done.length > 0) {
-      console.warn(`invitation to ${instanceName} already accepted`, done);
-      throw new CommanderError(1, 'EALREADY', `already accepted`);
-    }
-  };
-
-  /**
-   * Make an offer from agoricNames, wallet status; sign and broadcast it,
-   * given a sendFrom address; else print it.
-   *
-   * @param {{
-   *   toOffer: (agoricNames: *, current: import('@agoric/smart-wallet/src/smartWallet').CurrentWalletRecord | undefined) => OfferSpec,
-   *   sendFrom?: string | undefined,
-   *   instanceName?: string,
-   * }} detail
-   * @param {Awaited<ReturnType<makeRpcUtils>>} [optUtils]
-   */
-  const processOffer = async function ({ toOffer, sendFrom }, optUtils) {
-    const networkConfig = await getNetworkConfig(env);
-    const utils = await (optUtils || makeRpcUtils({ fetch }));
-    const { agoricNames, readLatestHead } = utils;
-
-    let current;
-    if (sendFrom) {
-      current = await getCurrent(sendFrom, { readLatestHead });
-    }
-
-    const offer = toOffer(agoricNames, current);
-    if (!sendFrom) {
-      outputActionAndHint(
-        { method: 'executeOffer', offer },
-        { stdout, stderr },
-      );
-      return;
-    }
-
-    const result = await sendAction(
-      { method: 'executeOffer', offer },
-      {
-        keyring: { backend: 'test' }, // XXX
-        from: sendFrom,
-        verbose: false,
-        ...networkConfig,
-        execFileSync,
-        stdout,
-        delay,
-      },
-    );
-    assert(result); // not dry-run
-    const { timestamp, txhash, height } = result;
-    console.error('wallet action is broadcast:');
-    show({ timestamp, height, offerId: offer.id, txhash });
-    const checkInWallet = async blockInfo => {
-      const [state, update] = await Promise.all([
-        getCurrent(sendFrom, { readLatestHead }),
-        getLastUpdate(sendFrom, { readLatestHead }),
-        readLatestHead(`published.wallet.${sendFrom}`),
-      ]);
-      if (update.updated === 'offerStatus' && update.status.id === offer.id) {
-        return blockInfo;
-      }
-      const info = await findContinuingIds(state, agoricNames);
-      const done = info.filter(it => it.offerId === offer.id);
-      if (!(done.length > 0)) throw Error('retry');
-      return blockInfo;
-    };
-    const blockInfo = await pollBlocks({
-      retryMessage: 'offer not yet in block',
-      ...networkConfig,
-      execFileSync,
-      delay,
-    })(checkInWallet);
-    console.error('offer accepted in block');
-    show(blockInfo);
-  };
-
-  ec.command('committee')
-    .description('accept invitation to join the economic committee')
-    .option('--voter <number>', 'Voter number', Number, 0)
-    .option(
-      '--offerId <string>',
-      'Offer id',
-      String,
-      `ecCommittee-${Date.now()}`,
-    )
-    .option(
-      '--send-from <name-or-address>',
-      'Send from address',
-      normalizeAddress,
-    )
-    .action(async function (opts) {
-      /** @type {Parameters<typeof processOffer>[0]['toOffer']} */
-      const toOffer = (agoricNames, current) => {
-        const instance = agoricNames.instance.economicCommittee;
-        assert(instance, `missing economicCommittee`);
-
-        if (current) {
-          const found = findContinuingIds(current, agoricNames);
-          abortIfSeen('economicCommittee', found);
-        }
-
-        return {
-          id: opts.offerId,
-          invitationSpec: {
-            source: 'purse',
-            instance,
-            description: `Voter${opts.voter}`,
-          },
-          proposal: {},
-        };
-      };
-
-      await processOffer({
-        toOffer,
-        instanceName: 'economicCommittee',
-        ...opts,
-      });
-    });
-
-  ec.command('charter')
-    .description('accept the charter invitation')
-    .option('--offerId <string>', 'Offer id', String, `ecCharter-${Date.now()}`)
-    .option(
-      '--send-from <name-or-address>',
-      'Send from address',
-      normalizeAddress,
-    )
-    .action(async function (opts) {
-      /** @type {Parameters<typeof processOffer>[0]['toOffer']} */
-      const toOffer = (agoricNames, current) => {
-        const instance = agoricNames.instance.econCommitteeCharter;
-        assert(instance, `missing econCommitteeCharter`);
-
-        if (current) {
-          const found = findContinuingIds(current, agoricNames);
-          abortIfSeen('econCommitteeCharter', found);
-        }
-
-        return {
-          id: opts.offerId,
-          invitationSpec: {
-            source: 'purse',
-            instance,
-            description: 'charter member invitation',
-          },
-          proposal: {},
-        };
-      };
-
-      await processOffer({
-        toOffer,
-        instanceName: 'econCommitteeCharter',
-        ...opts,
-      });
-    });
-
-  ec.command('find-continuing-id')
-    .description('print id of specified voting continuing invitation')
-    .requiredOption(
-      '--from <name-or-address>',
-      'from address',
-      normalizeAddress,
-    )
-    .requiredOption('--for <string>', 'description of the invitation')
-    .action(async opts => {
-      const { agoricNames, readLatestHead } = await makeRpcUtils({ fetch });
-      const current = await getCurrent(opts.from, { readLatestHead });
-
-      const known = findContinuingIds(current, agoricNames);
-      if (!known) {
-        console.error('No continuing ids found');
-        return;
-      }
-      const match = known.find(r => r.description === opts.for);
-      if (!match) {
-        console.error(`No match found for '${opts.for}'`);
-        return;
-      }
-
-      console.log(match.offerId);
-    });
-
-  ec.command('find-continuing-ids')
-    .description('print records of voting continuing invitations')
-    .requiredOption(
-      '--from <name-or-address>',
-      'from address',
-      normalizeAddress,
-    )
-    .action(async opts => {
-      const { agoricNames, readLatestHead } = await makeRpcUtils({ fetch });
-      const current = await getCurrent(opts.from, { readLatestHead });
-
-      const found = findContinuingIds(current, agoricNames);
-      found.forEach(it => show({ ...it, address: opts.from }));
-    });
-
-  ec.command('vote')
-    .description('vote on a question (hard-coded for now))')
-    .option('--offerId <number>', 'Offer id', String, `ecVote-${Date.now()}`)
-    .requiredOption(
-      '--forPosition <number>',
-      'index of one position to vote for (within the question description.positions); ',
-      Number,
-    )
-    .requiredOption(
-      '--send-from <name-or-address>',
-      'Send from address',
-      normalizeAddress,
-    )
-    .action(async function (opts) {
-      const utils = await makeRpcUtils({ fetch });
-      const { readLatestHead } = utils;
-
-      const info = await readLatestHead(
-        'published.committees.Economic_Committee.latestQuestion',
-      ).catch(err => {
-        throw new CommanderError(1, 'VSTORAGE_FAILURE', err.message);
-      });
-      // XXX runtime shape-check
-      const questionDesc = /** @type {any} */ (info);
-
-      // TODO support multiple position arguments
-      const chosenPositions = [questionDesc.positions[opts.forPosition]];
-      assert(chosenPositions, `undefined position index ${opts.forPosition}`);
-
-      /** @type {Parameters<typeof processOffer>[0]['toOffer']} */
-      const toOffer = (agoricNames, current) => {
-        const cont = current ? findContinuingIds(current, agoricNames) : [];
-        const votingRight = cont.find(
-          it => it.instance === agoricNames.instance.economicCommittee,
-        );
-        if (!votingRight) {
-          console.debug('continuing ids', cont, 'for', current);
-          throw new CommanderError(
-            1,
-            'NO_INVITATION',
-            'first, try: agops ec committee ...',
-          );
-        }
-        return {
-          id: opts.offerId,
-          invitationSpec: {
-            source: 'continuing',
-            previousOffer: votingRight.offerId,
-            invitationMakerName: 'makeVoteInvitation',
-            // (positionList, questionHandle)
-            invitationArgs: harden([
-              chosenPositions,
-              questionDesc.questionHandle,
-            ]),
-          },
-          proposal: {},
-        };
-      };
-
-      await processOffer({ toOffer, sendFrom: opts.sendFrom }, utils);
-    });
-
-  return ec;
-};

package/src/lib/rpc.js

@@ -1,272 +0,0 @@
-// @ts-check
-/* eslint-disable @jessie.js/no-nested-await */
-/* global Buffer, fetch, process */
-
-import { NonNullish } from '@agoric/assert';
-import {
-  boardSlottingMarshaller,
-  makeBoardRemote,
-} from '@agoric/vats/tools/board-utils.js';
-
-export { boardSlottingMarshaller };
-
-export const networkConfigUrl = agoricNetSubdomain =>
-  `https://${agoricNetSubdomain}.agoric.net/network-config`;
-export const rpcUrl = agoricNetSubdomain =>
-  `https://${agoricNetSubdomain}.rpc.agoric.net:443`;
-
-/**
- * @typedef {{ rpcAddrs: string[], chainName: string }} MinimalNetworkConfig
- */
-
-/**
- *  @param {string} str
- * @returns {Promise<MinimalNetworkConfig>}
- */
-const fromAgoricNet = str => {
-  const [netName, chainName] = str.split(',');
-  if (chainName) {
-    return Promise.resolve({ chainName, rpcAddrs: [rpcUrl(netName)] });
-  }
-  return fetch(networkConfigUrl(netName)).then(res => res.json());
-};
-
-/**
- * @param {typeof process.env} env
- * @returns {Promise<MinimalNetworkConfig>}
- */
-export const getNetworkConfig = async env => {
-  if (!('AGORIC_NET' in env) || env.AGORIC_NET === 'local') {
-    return { rpcAddrs: ['http://0.0.0.0:26657'], chainName: 'agoriclocal' };
-  }
-
-  return fromAgoricNet(NonNullish(env.AGORIC_NET)).catch(err => {
-    throw Error(
-      `cannot get network config (${env.AGORIC_NET || 'local'}): ${
-        err.message
-      }`,
-    );
-  });
-};
-
-/** @type {MinimalNetworkConfig} */
-export const networkConfig = await getNetworkConfig(process.env);
-// console.warn('networkConfig', networkConfig);
-
-/**
- * @param {object} powers
- * @param {typeof window.fetch} powers.fetch
- * @param {MinimalNetworkConfig} config
- */
-export const makeVStorage = (powers, config = networkConfig) => {
-  /** @param {string} path */
-  const getJSON = path => {
-    const url = config.rpcAddrs[0] + path;
-    // console.warn('fetching', url);
-    return powers.fetch(url, { keepalive: true }).then(res => res.json());
-  };
-  // height=0 is the same as omitting height and implies the highest block
-  const url = (path = 'published', { kind = 'children', height = 0 } = {}) =>
-    `/abci_query?path=%22/custom/vstorage/${kind}/${path}%22&height=${height}`;
-
-  const readStorage = (path = 'published', { kind = 'children', height = 0 }) =>
-    getJSON(url(path, { kind, height }))
-      .catch(err => {
-        throw Error(`cannot read ${kind} of ${path}: ${err.message}`);
-      })
-      .then(data => {
-        const {
-          result: { response },
-        } = data;
-        if (response?.code !== 0) {
-          throw Error(
-            `error code ${response?.code} reading ${kind} of ${path}: ${response.log}`,
-          );
-        }
-        return data;
-      });
-
-  return {
-    url,
-    decode({ result: { response } }) {
-      const { code } = response;
-      if (code !== 0) {
-        throw response;
-      }
-      const { value } = response;
-      return Buffer.from(value, 'base64').toString();
-    },
-    /**
-     *
-     * @param {string} path
-     * @returns {Promise<string>} latest vstorage value at path
-     */
-    async readLatest(path = 'published') {
-      const raw = await readStorage(path, { kind: 'data' });
-      return this.decode(raw);
-    },
-    async keys(path = 'published') {
-      const raw = await readStorage(path, { kind: 'children' });
-      return JSON.parse(this.decode(raw)).children;
-    },
-    /**
-     * @param {string} path
-     * @param {number} [height] default is highest
-     * @returns {Promise<{blockHeight: number, values: string[]}>}
-     */
-    async readAt(path, height = undefined) {
-      const raw = await readStorage(path, { kind: 'data', height });
-      const txt = this.decode(raw);
-      /** @type {{ value: string }} */
-      const { value } = JSON.parse(txt);
-      return JSON.parse(value);
-    },
-    /**
-     * Read values going back as far as available
-     *
-     * @param {string} path
-     * @param {number | string} [minHeight]
-     * @returns {Promise<string[]>}
-     */
-    async readFully(path, minHeight = undefined) {
-      const parts = [];
-      // undefined the first iteration, to query at the highest
-      let blockHeight;
-      do {
-        // console.debug('READING', { blockHeight });
-        let values;
-        try {
-          // eslint-disable-next-line no-await-in-loop
-          ({ blockHeight, values } = await this.readAt(
-            path,
-            blockHeight && Number(blockHeight) - 1,
-          ));
-          // console.debug('readAt returned', { blockHeight });
-        } catch (err) {
-          if (err.message.match(/unknown request/)) {
-            // console.error(err);
-            break;
-          }
-          throw err;
-        }
-        parts.push(values);
-        // console.debug('PUSHED', values);
-        // console.debug('NEW', { blockHeight, minHeight });
-        if (minHeight && Number(blockHeight) <= Number(minHeight)) break;
-      } while (blockHeight > 0);
-      return parts.flat();
-    },
-  };
-};
-/** @typedef {ReturnType<typeof makeVStorage>} VStorage */
-
-export const makeFromBoard = () => {
-  const cache = new Map();
-  const convertSlotToVal = (boardId, iface) => {
-    if (cache.has(boardId)) {
-      return cache.get(boardId);
-    }
-    const val = makeBoardRemote({ boardId, iface });
-    cache.set(boardId, val);
-    return val;
-  };
-  return harden({ convertSlotToVal });
-};
-/** @typedef {ReturnType<typeof makeFromBoard>} IdMap */
-
-export const storageHelper = {
-  /** @param { string } txt */
-  parseCapData: txt => {
-    assert(typeof txt === 'string', typeof txt);
-    /** @type {{ value: string }} */
-    const { value } = JSON.parse(txt);
-    const specimen = JSON.parse(value);
-    const { blockHeight, values } = specimen;
-    assert(values, `empty values in specimen ${value}`);
-    const capDatas = storageHelper.parseMany(values);
-    return { blockHeight, capDatas };
-  },
-  /**
-   * @param {string} txt
-   * @param {IdMap} ctx
-   */
-  unserializeTxt: (txt, ctx) => {
-    const { capDatas } = storageHelper.parseCapData(txt);
-    return capDatas.map(capData =>
-      boardSlottingMarshaller(ctx.convertSlotToVal).fromCapData(capData),
-    );
-  },
-  /** @param {string[]} capDataStrings array of stringified capData */
-  parseMany: capDataStrings => {
-    assert(capDataStrings && capDataStrings.length);
-    /** @type {{ body: string, slots: string[] }[]} */
-    const capDatas = capDataStrings.map(s => JSON.parse(s));
-    for (const capData of capDatas) {
-      assert(typeof capData === 'object' && capData !== null);
-      assert('body' in capData && 'slots' in capData);
-      assert(typeof capData.body === 'string');
-      assert(Array.isArray(capData.slots));
-    }
-    return capDatas;
-  },
-};
-harden(storageHelper);
-
-/**
- * @param {IdMap} ctx
- * @param {VStorage} vstorage
- * @returns {Promise<import('@agoric/vats/tools/board-utils.js').AgoricNamesRemotes>}
- */
-export const makeAgoricNames = async (ctx, vstorage) => {
-  const reverse = {};
-  const entries = await Promise.all(
-    ['brand', 'instance', 'vbankAsset'].map(async kind => {
-      const content = await vstorage.readLatest(
-        `published.agoricNames.${kind}`,
-      );
-      /** @type {Array<[string, import('@agoric/vats/tools/board-utils.js').BoardRemote]>} */
-      const parts = storageHelper.unserializeTxt(content, ctx).at(-1);
-      for (const [name, remote] of parts) {
-        if ('getBoardId' in remote) {
-          reverse[remote.getBoardId()] = name;
-        }
-      }
-      return [kind, Object.fromEntries(parts)];
-    }),
-  );
-  return { ...Object.fromEntries(entries), reverse };
-};
-
-/**
- * @param {{ fetch: typeof window.fetch }} io
- * @param {MinimalNetworkConfig} config
- */
-export const makeRpcUtils = async ({ fetch }, config = networkConfig) => {
-  try {
-    const vstorage = makeVStorage({ fetch }, config);
-    const fromBoard = makeFromBoard();
-    const agoricNames = await makeAgoricNames(fromBoard, vstorage);
-
-    const unserializer = boardSlottingMarshaller(fromBoard.convertSlotToVal);
-
-    /** @type {(txt: string) => unknown} */
-    const unserializeHead = txt =>
-      storageHelper.unserializeTxt(txt, fromBoard).at(-1);
-
-    /** @type {(path: string) => Promise<unknown>} */
-    const readLatestHead = path =>
-      vstorage.readLatest(path).then(unserializeHead);
-
-    return {
-      agoricNames,
-      fromBoard,
-      readLatestHead,
-      unserializeHead,
-      unserializer,
-      vstorage,
-    };
-  } catch (err) {
-    throw Error(`RPC failure (${config.rpcAddrs}): ${err.message}`);
-  }
-};
-/** @typedef {Awaited<ReturnType<typeof makeRpcUtils>>} RpcUtils */