@agoric/client-utils 0.1.1-other-dev-3eb1a1d.0 → 0.1.1-other-dev-fbe72e7.0.fbe72e7

package/src/vstorage-kit.js

@@ -1,264 +0,0 @@
-/* global Buffer */
-import {
-  boardSlottingMarshaller,
-  makeBoardRemote,
-} from '@agoric/vats/tools/board-utils.js';
-
-export { boardSlottingMarshaller };
-
-/**
- * @import {MinimalNetworkConfig} from './rpc.js';
- * @import {TypedPublished} from './types.js';
- */
-
-/**
- * @param {object} powers
- * @param {typeof window.fetch} powers.fetch
- * @param {MinimalNetworkConfig} config
- */
-export const makeVStorage = (powers, config) => {
-  /** @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) {
-          /** @type {any} */
-          const err = Error(
-            `error code ${response?.code} reading ${kind} of ${path}: ${response.log}`,
-          );
-          err.code = response?.code;
-          err.codespace = response?.codespace;
-          throw err;
-        }
-        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;
-      await null;
-      do {
-        // console.debug('READING', { blockHeight });
-        let values;
-        try {
-          ({ blockHeight, values } = await this.readAt(
-            path,
-            blockHeight && Number(blockHeight) - 1,
-          ));
-          // console.debug('readAt returned', { blockHeight });
-        } catch (err) {
-          if (
-            // CosmosSDK ErrInvalidRequest with particular message text;
-            // misrepresentation of pruned data
-            // TODO replace after incorporating a fix to
-            // https://github.com/cosmos/cosmos-sdk/issues/19992
-            err.codespace === 'sdk' &&
-            err.code === 18 &&
-            err.message.match(/pruned/)
-          ) {
-            // 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 */
-
-/** @deprecated */
-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 */
-
-/** @deprecated */
-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);
-
-/**
- * @deprecated
- * @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 makeVstorageKit = async ({ fetch }, config) => {
-  await null;
-  try {
-    const vstorage = makeVStorage({ fetch }, config);
-    const fromBoard = makeFromBoard();
-    const agoricNames = await makeAgoricNames(fromBoard, vstorage);
-
-    const marshaller = boardSlottingMarshaller(fromBoard.convertSlotToVal);
-
-    /** @type {(txt: string) => unknown} */
-    const unserializeHead = txt =>
-      storageHelper.unserializeTxt(txt, fromBoard).at(-1);
-
-    /**
-     * Read latest at path and unmarshal it
-     * @type {(path: string) => Promise<unknown>}
-     */
-    const readLatestHead = path =>
-      vstorage.readLatest(path).then(unserializeHead);
-
-    /**
-     * Read latest at published path and unmarshal it.
-     *
-     * Note this does not perform a runtime check to verify the shape. The
-     * static types come from the spec of what is supposed to be written to
-     * vstorage, which is validated in testing of the chain code that is run
-     * in consensus.
-     *
-     * @type {<T extends string>(subpath: T) => Promise<TypedPublished<T>>}
-     */
-    const readPublished = subpath =>
-      // @ts-expect-error cast
-      readLatestHead(`published.${subpath}`);
-
-    return {
-      agoricNames,
-      fromBoard,
-      marshaller,
-      readLatestHead,
-      readPublished,
-      unserializeHead,
-      vstorage,
-    };
-  } catch (err) {
-    throw Error(`RPC failure (${config.rpcAddrs}): ${err.message}`);
-  }
-};
-/** @typedef {Awaited<ReturnType<typeof makeVstorageKit>>} VstorageKit */

package/src/wallet-utils.js

@@ -1,113 +0,0 @@
-import { makeWalletStateCoalescer } from '@agoric/smart-wallet/src/utils.js';
-import { pollBlocks } from './chain.js';
-import { makeStargateClient } from './rpc.js';
-import { boardSlottingMarshaller, makeVstorageKit } from './vstorage-kit.js';
-
-/**
- * @import {Amount, Brand} from '@agoric/ertp/src/types.js'
- * @import {CurrentWalletRecord, UpdateRecord} from '@agoric/smart-wallet/src/smartWallet.js';
- * @import {MinimalNetworkConfig} from './rpc.js';
- */
-
-// XXX this is really a SmartWalletKit
-/**
- * Augment VstorageKit with addtional convenience methods for working with
- * Agoric smart wallets.
- *
- * @param {object} root0
- * @param {typeof globalThis.fetch} root0.fetch
- * @param {(ms: number) => Promise<void>} root0.delay
- * @param {MinimalNetworkConfig} networkConfig
- */
-export const makeWalletUtils = async ({ fetch, delay }, networkConfig) => {
-  const vsk = await makeVstorageKit({ fetch }, networkConfig);
-
-  const m = boardSlottingMarshaller(vsk.fromBoard.convertSlotToVal);
-
-  const client = await makeStargateClient(networkConfig, { fetch });
-
-  /**
-   * @param {string} from
-   * @param {number|string} [minHeight]
-   */
-  const storedWalletState = async (from, minHeight = undefined) => {
-    const history = await vsk.vstorage.readFully(
-      `published.wallet.${from}`,
-      minHeight,
-    );
-
-    /** @type {{ Invitation: Brand<'set'> }} */
-    // @ts-expect-error XXX how to narrow AssetKind to set?
-    const { Invitation } = vsk.agoricNames.brand;
-    const coalescer = makeWalletStateCoalescer(Invitation);
-    // update with oldest first
-    for (const txt of history.reverse()) {
-      const { body, slots } = JSON.parse(txt);
-      const record = m.fromCapData({ body, slots });
-      coalescer.update(record);
-    }
-    const coalesced = coalescer.state;
-    harden(coalesced);
-    return coalesced;
-  };
-
-  /**
-   * Get OfferStatus by id, polling until available.
-   *
-   * @param {string} from
-   * @param {string|number} id
-   * @param {number|string} minHeight
-   * @param {boolean} [untilNumWantsSatisfied]
-   */
-  const pollOffer = async (
-    from,
-    id,
-    minHeight,
-    untilNumWantsSatisfied = false,
-  ) => {
-    const poll = pollBlocks({
-      client,
-      delay,
-      retryMessage: 'offer not in wallet at block',
-    });
-
-    const lookup = async () => {
-      const { offerStatuses } = await storedWalletState(from, minHeight);
-      const offerStatus = [...offerStatuses.values()].find(s => s.id === id);
-      if (!offerStatus) throw Error('retry');
-      harden(offerStatus);
-      if (untilNumWantsSatisfied && !('numWantsSatisfied' in offerStatus)) {
-        throw Error('retry (no numWantsSatisfied yet)');
-      }
-      return offerStatus;
-    };
-    return poll(lookup);
-  };
-
-  /**
-   * @param {string} addr
-   * @returns {Promise<UpdateRecord>}
-   */
-  const getLastUpdate = addr => {
-    return vsk.readPublished(`wallet.${addr}`);
-  };
-
-  /**
-   * @param {string} addr
-   * @returns {Promise<CurrentWalletRecord>}
-   */
-  const getCurrentWalletRecord = addr => {
-    return vsk.readPublished(`wallet.${addr}.current`);
-  };
-
-  return {
-    // pass along all of VstorageKit
-    ...vsk,
-    networkConfig,
-    getLastUpdate,
-    getCurrentWalletRecord,
-    storedWalletState,
-    pollOffer,
-  };
-};
-/** @typedef {Awaited<ReturnType<typeof makeWalletUtils>>} WalletUtils */