agoric 0.18.4 → 0.18.5-dev-800c2bb.0

package/src/lib/rpc.js

@@ -3,10 +3,12 @@
 /* global Buffer, fetch, process */
 
 import { NonNullish } from '@agoric/assert';
+import {
+  boardSlottingMarshaller,
+  makeBoardRemote,
+} from '@agoric/vats/tools/board-utils.js';
 
-/**
- * @typedef {{boardId: string, iface: string}} RpcRemote
- */
+export { boardSlottingMarshaller };
 
 export const networkConfigUrl = agoricNetSubdomain =>
   `https://${agoricNetSubdomain}.agoric.net/network-config`;
@@ -29,29 +31,63 @@ const fromAgoricNet = str => {
   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 =
-  'AGORIC_NET' in process.env && process.env.AGORIC_NET !== 'local'
-    ? await fromAgoricNet(NonNullish(process.env.AGORIC_NET))
-    : { rpcAddrs: ['http://0.0.0.0:26657'], chainName: 'agoriclocal' };
+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 => {
+export const makeVStorage = (powers, config = networkConfig) => {
+  /** @param {string} path */
   const getJSON = path => {
-    const url = networkConfig.rpcAddrs[0] + 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 {
-    // height=0 is the same as omitting height and implies the highest block
-    url: (path = 'published', { kind = 'children', height = 0 } = {}) =>
-      `/abci_query?path=%22/custom/vstorage/${kind}/${path}%22&height=${height}`,
+    url,
     decode({ result: { response } }) {
       const { code } = response;
       if (code !== 0) {
@@ -66,11 +102,11 @@ export const makeVStorage = powers => {
      * @returns {Promise<string>} latest vstorage value at path
      */
     async readLatest(path = 'published') {
-      const raw = await getJSON(this.url(path, { kind: 'data' }));
+      const raw = await readStorage(path, { kind: 'data' });
       return this.decode(raw);
     },
     async keys(path = 'published') {
-      const raw = await getJSON(this.url(path, { kind: 'children' }));
+      const raw = await readStorage(path, { kind: 'children' });
       return JSON.parse(this.decode(raw)).children;
     },
     /**
@@ -79,7 +115,7 @@ export const makeVStorage = powers => {
      * @returns {Promise<{blockHeight: number, values: string[]}>}
      */
     async readAt(path, height = undefined) {
-      const raw = await getJSON(this.url(path, { kind: 'data', height }));
+      const raw = await readStorage(path, { kind: 'data', height });
       const txt = this.decode(raw);
       /** @type {{ value: string }} */
       const { value } = JSON.parse(txt);
@@ -89,32 +125,34 @@ export const makeVStorage = powers => {
      * Read values going back as far as available
      *
      * @param {string} path
+     * @param {number | string} [minHeight]
      * @returns {Promise<string[]>}
      */
-    async readFully(path) {
+    async readFully(path, minHeight = undefined) {
       const parts = [];
       // undefined the first iteration, to query at the highest
       let blockHeight;
       do {
-        console.debug('READING', { blockHeight });
+        // console.debug('READING', { blockHeight });
         let values;
         try {
           // eslint-disable-next-line no-await-in-loop
           ({ blockHeight, values } = await this.readAt(
             path,
-            blockHeight && blockHeight - 1,
+            blockHeight && Number(blockHeight) - 1,
           ));
-          console.debug('readAt returned', { blockHeight });
+          // console.debug('readAt returned', { blockHeight });
         } catch (err) {
-          if ('log' in err && err.log.match(/unknown request/)) {
-            console.error(err);
+          if (err.message.match(/unknown request/)) {
+            // console.error(err);
             break;
           }
           throw err;
         }
         parts.push(values);
-        console.debug('PUSHED', values);
-        console.debug('NEW', { blockHeight });
+        // console.debug('PUSHED', values);
+        // console.debug('NEW', { blockHeight, minHeight });
+        if (minHeight && Number(blockHeight) <= Number(minHeight)) break;
       } while (blockHeight > 0);
       return parts.flat();
     },
@@ -122,76 +160,14 @@ export const makeVStorage = powers => {
 };
 /** @typedef {ReturnType<typeof makeVStorage>} VStorage */
 
-/**
- * Like makeMarshal but,
- * - slotToVal takes an iface arg
- * - if a part being serialized has a boardId property, it passes through as a slot value whereas the normal marshaller would treat it as a copyRecord
- *
- * @param {(slot: string, iface: string) => any} slotToVal
- * @returns {import('@endo/marshal').Marshal<string>}
- */
-export const boardSlottingMarshaller = (slotToVal = (s, _i) => s) => ({
-  /** @param {{body: string, slots: string[]}} capData */
-  unserialize: ({ body, slots }) => {
-    const reviver = (_key, obj) => {
-      const qclass = obj !== null && typeof obj === 'object' && obj['@qclass'];
-      // NOTE: hilbert hotel not impl
-      switch (qclass) {
-        case 'slot': {
-          const { index, iface } = obj;
-          return slotToVal(slots[index], iface);
-        }
-        case 'bigint':
-          return BigInt(obj.digits);
-        case 'undefined':
-          return undefined;
-        default:
-          return obj;
-      }
-    };
-    return JSON.parse(body, reviver);
-  },
-  serialize: whole => {
-    const seen = new Map();
-    const slotIndex = v => {
-      if (seen.has(v)) {
-        return seen.get(v);
-      }
-      const index = seen.size;
-      seen.set(v, index);
-      return { index, iface: v.iface };
-    };
-    const recur = part => {
-      if (part === null) return null;
-      if (typeof part === 'bigint') {
-        return { '@qclass': 'bigint', digits: `${part}` };
-      }
-      if (Array.isArray(part)) {
-        return part.map(recur);
-      }
-      if (typeof part === 'object') {
-        if ('boardId' in part) {
-          return { '@qclass': 'slot', ...slotIndex(part.boardId) };
-        }
-        return Object.fromEntries(
-          Object.entries(part).map(([k, v]) => [k, recur(v)]),
-        );
-      }
-      return part;
-    };
-    const after = recur(whole);
-    return { body: JSON.stringify(after), slots: [...seen.keys()] };
-  },
-});
-
-export const makeFromBoard = (slotKey = 'boardId') => {
+export const makeFromBoard = () => {
   const cache = new Map();
-  const convertSlotToVal = (slot, iface) => {
-    if (cache.has(slot)) {
-      return cache.get(slot);
+  const convertSlotToVal = (boardId, iface) => {
+    if (cache.has(boardId)) {
+      return cache.get(boardId);
     }
-    const val = harden({ [slotKey]: slot, iface });
-    cache.set(slot, val);
+    const val = makeBoardRemote({ boardId, iface });
+    cache.set(boardId, val);
     return val;
   };
   return harden({ convertSlotToVal });
@@ -217,7 +193,7 @@ export const storageHelper = {
   unserializeTxt: (txt, ctx) => {
     const { capDatas } = storageHelper.parseCapData(txt);
     return capDatas.map(capData =>
-      boardSlottingMarshaller(ctx.convertSlotToVal).unserialize(capData),
+      boardSlottingMarshaller(ctx.convertSlotToVal).fromCapData(capData),
     );
   },
   /** @param {string[]} capDataStrings array of stringified capData */
@@ -239,18 +215,21 @@ harden(storageHelper);
 /**
  * @param {IdMap} ctx
  * @param {VStorage} vstorage
- * @returns {Promise<{ brand: Record<string, RpcRemote>, instance: Record<string, RpcRemote>, reverse: Record<string, string> }>}
+ * @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'].map(async kind => {
+    ['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) {
-        reverse[remote.boardId] = name;
+        if ('getBoardId' in remote) {
+          reverse[remote.getBoardId()] = name;
+        }
       }
       return [kind, Object.fromEntries(parts)];
     }),
@@ -258,10 +237,36 @@ export const makeAgoricNames = async (ctx, vstorage) => {
   return { ...Object.fromEntries(entries), reverse };
 };
 
-export const makeRpcUtils = async ({ fetch }) => {
-  const vstorage = makeVStorage({ fetch });
-  const fromBoard = makeFromBoard();
-  const agoricNames = await makeAgoricNames(fromBoard, vstorage);
+/**
+ * @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);
 
-  return { vstorage, fromBoard, agoricNames };
+    /** @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 */

package/src/lib/wallet.js

@@ -1,20 +1,315 @@
 // @ts-check
+/* global process */
 
-import { storageHelper } from './rpc.js';
+import { iterateReverse } from '@agoric/casting';
+import { makeWalletStateCoalescer } from '@agoric/smart-wallet/src/utils.js';
+import { execSwingsetTransaction, pollBlocks, pollTx } from './chain.js';
+import { boardSlottingMarshaller, makeRpcUtils } from './rpc.js';
+
+/** @typedef {import('@agoric/smart-wallet/src/smartWallet.js').CurrentWalletRecord} CurrentWalletRecord  */
+/** @typedef {import('@agoric/vats/tools/board-utils.js').AgoricNamesRemotes} AgoricNamesRemotes  */
+
+const { values } = Object;
+const { Fail } = assert;
+const marshaller = boardSlottingMarshaller();
+
+/** @type {CurrentWalletRecord} */
+const emptyCurrentRecord = {
+  purses: [],
+  offerToUsedInvitation: [],
+  offerToPublicSubscriberPaths: [],
+  liveOffers: [],
+};
 
 /**
  * @param {string} addr
- * @param {import('./rpc').IdMap} ctx
- * @param {object} io
- * @param {import('./rpc.js').VStorage} io.vstorage
+ * @param {Pick<import('./rpc.js').RpcUtils, 'readLatestHead'>} io
  * @returns {Promise<import('@agoric/smart-wallet/src/smartWallet').CurrentWalletRecord>}
  */
-export const getCurrent = async (addr, ctx, { vstorage }) => {
-  const capDataStr = await vstorage.readLatest(
-    `published.wallet.${addr}.current`,
-  );
+export const getCurrent = async (addr, { readLatestHead }) => {
+  // Partial because older writes may not have had all properties
+  // NB: assumes changes are only additions
+  let current =
+    /** @type {Partial<import('@agoric/smart-wallet/src/smartWallet').CurrentWalletRecord> | undefined} */ (
+      await readLatestHead(`published.wallet.${addr}.current`)
+    );
+  if (current === undefined) {
+    throw new Error(`undefined current node for ${addr}`);
+  }
+
+  // Repair a type misunderstanding seen in the wild.
+  // See https://github.com/Agoric/agoric-sdk/pull/7139
+  let offerToUsedInvitation = current.offerToUsedInvitation;
+  if (
+    offerToUsedInvitation &&
+    typeof offerToUsedInvitation === 'object' &&
+    !Array.isArray(offerToUsedInvitation)
+  ) {
+    offerToUsedInvitation = Object.entries(offerToUsedInvitation);
+    current = harden({
+      ...current,
+      offerToUsedInvitation,
+    });
+  }
+
+  // override full empty record with defined values from published one
+  return { ...emptyCurrentRecord, ...current };
+};
+
+/**
+ * @param {string} addr
+ * @param {Pick<import('./rpc.js').RpcUtils, 'readLatestHead'>} io
+ * @returns {Promise<import('@agoric/smart-wallet/src/smartWallet').UpdateRecord>}
+ */
+export const getLastUpdate = (addr, { readLatestHead }) => {
+  // @ts-expect-error cast
+  return readLatestHead(`published.wallet.${addr}`);
+};
+
+/**
+ * @param {import('@agoric/smart-wallet/src/smartWallet').BridgeAction} bridgeAction
+ * @param {Pick<import('stream').Writable,'write'>} [stdout]
+ */
+export const outputAction = (bridgeAction, stdout = process.stdout) => {
+  const capData = marshaller.toCapData(harden(bridgeAction));
+  stdout.write(JSON.stringify(capData));
+  stdout.write('\n');
+};
+
+const sendHint =
+  'Now use `agoric wallet send ...` to sign and broadcast the offer.\n';
+
+/**
+ * @param {import('@agoric/smart-wallet/src/smartWallet').BridgeAction} bridgeAction
+ * @param {{
+ *   stdout: Pick<import('stream').Writable,'write'>,
+ *   stderr: Pick<import('stream').Writable,'write'>,
+ * }} io
+ */
+export const outputActionAndHint = (bridgeAction, { stdout, stderr }) => {
+  outputAction(bridgeAction, stdout);
+  stderr.write(sendHint);
+};
+
+/**
+ * @param {import('@agoric/smart-wallet/src/offers.js').OfferSpec} offer
+ * @param {Pick<import('stream').Writable,'write'>} [stdout]
+ */
+export const outputExecuteOfferAction = (offer, stdout = process.stdout) => {
+  /** @type {import('@agoric/smart-wallet/src/smartWallet').BridgeAction} */
+  const spendAction = {
+    method: 'executeOffer',
+    offer,
+  };
+  outputAction(spendAction, stdout);
+};
+
+/**
+ * @deprecated use `.current` node for current state
+ * @param {import('@agoric/casting').Follower<import('@agoric/casting').ValueFollowerElement<import('@agoric/smart-wallet/src/smartWallet').UpdateRecord>>} follower
+ * @param {Brand<'set'>} [invitationBrand]
+ */
+export const coalesceWalletState = async (follower, invitationBrand) => {
+  // values with oldest last
+  const history = [];
+  for await (const followerElement of iterateReverse(follower)) {
+    history.push(followerElement.value);
+  }
+
+  const coalescer = makeWalletStateCoalescer(invitationBrand);
+  // update with oldest first
+  for (const record of history.reverse()) {
+    coalescer.update(record);
+  }
+
+  return coalescer.state;
+};
+
+/**
+ * Sign and broadcast a wallet-action.
+ *
+ * @throws { Error & { code: number } } if transaction fails
+ * @param {import('@agoric/smart-wallet/src/smartWallet').BridgeAction} bridgeAction
+ * @param {import('./rpc').MinimalNetworkConfig & {
+ *   from: string,
+ *   verbose?: boolean,
+ *   keyring?: {home?: string, backend: string},
+ *   stdout: Pick<import('stream').Writable, 'write'>,
+ *   execFileSync: typeof import('child_process').execFileSync,
+ *   delay: (ms: number) => Promise<void>,
+ *   dryRun?: boolean,
+ * }} opts
+ */
+export const sendAction = async (bridgeAction, opts) => {
+  const offerBody = JSON.stringify(marshaller.toCapData(harden(bridgeAction)));
+
+  // tryExit should not require --allow-spend
+  // https://github.com/Agoric/agoric-sdk/issues/7291
+  const spendMethods = ['executeOffer', 'tryExitOffer'];
+  const spendArg = spendMethods.includes(bridgeAction.method)
+    ? ['--allow-spend']
+    : [];
+
+  const act = ['wallet-action', ...spendArg, offerBody];
+  const out = execSwingsetTransaction([...act, '--output', 'json'], opts);
+  if (opts.dryRun) {
+    return;
+  }
+
+  assert(out); // not dry run
+  const tx = JSON.parse(out);
+  if (tx.code !== 0) {
+    const err = Error(`failed to send action. code: ${tx.code}`);
+    // @ts-expect-error XXX how to add properties to an error?
+    err.code = tx.code;
+    throw err;
+  }
+
+  return pollTx(tx.txhash, opts);
+};
+
+/**
+ * @param {CurrentWalletRecord} current
+ * @param {AgoricNamesRemotes} agoricNames
+ */
+export const findContinuingIds = (current, agoricNames) => {
+  // XXX should runtime type-check
+  /** @type {{ offerToUsedInvitation: [string, Amount<'set'>][]}} */
+  const { offerToUsedInvitation: entries } = /** @type {any} */ (current);
+
+  Array.isArray(entries) || Fail`entries must be an array: ${entries}`;
 
-  const capDatas = storageHelper.unserializeTxt(capDataStr, ctx);
+  const keyOf = (obj, val) => {
+    const found = Object.entries(obj).find(e => e[1] === val);
+    return found && found[0];
+  };
 
-  return capDatas[0];
+  const found = [];
+  for (const [offerId, { value }] of entries) {
+    /** @type {{ description: string, instance: unknown }[]} */
+    const [{ description, instance }] = value;
+    if (
+      description === 'charter member invitation' ||
+      /Voter\d+/.test(description)
+    ) {
+      const instanceName = keyOf(agoricNames.instance, instance);
+      found.push({ instance, instanceName, description, offerId });
+    }
+  }
+  return found;
 };
+
+export const makeWalletUtils = async (
+  { fetch, execFileSync, delay },
+  networkConfig,
+) => {
+  const { agoricNames, fromBoard, readLatestHead, vstorage } =
+    await makeRpcUtils({ fetch }, networkConfig);
+  /**
+   * @param {string} from
+   * @param {number|string} [minHeight]
+   */
+  const storedWalletState = async (from, minHeight = undefined) => {
+    const m = boardSlottingMarshaller(fromBoard.convertSlotToVal);
+
+    const history = await vstorage.readFully(
+      `published.wallet.${from}`,
+      minHeight,
+    );
+
+    /** @type {{ Invitation: Brand<'set'> }} */
+    // @ts-expect-error XXX how to narrow AssetKind to set?
+    const { Invitation } = 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 lookup = async () => {
+      // eslint-disable-next-line @jessie.js/no-nested-await, no-await-in-loop
+      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;
+    };
+    const retryMessage = 'offer not in wallet at block';
+    const opts = { ...networkConfig, execFileSync, delay, retryMessage };
+    return pollBlocks(opts)(lookup);
+  };
+
+  return {
+    networkConfig,
+    agoricNames,
+    fromBoard,
+    vstorage,
+    readLatestHead,
+    storedWalletState,
+    pollOffer,
+  };
+};
+
+/**
+ * @param {{
+ *   brand: Record<string, Brand>,
+ *   vbankAsset: Record<string, { brand: Brand, displayInfo: DisplayInfo }>,
+ * }} agoricNames
+ * @param {(msg: string) => Error} makeError error constructor
+ * @returns {(a: string) => Amount<'nat'>}
+ */
+export const makeParseAmount =
+  (agoricNames, makeError = msg => RangeError(msg)) =>
+  opt => {
+    assert.typeof(opt, 'string', 'parseAmount expected string');
+    const m = opt.match(/^(?<value>[\d_]+(\.[\d_]+)?)(?<brand>[A-Z]\w*?)$/);
+    if (!m || !m.groups) {
+      throw makeError(`invalid amount: ${opt}`);
+    }
+    const anyBrand = agoricNames.brand[m.groups.brand];
+    if (!anyBrand) {
+      throw makeError(`unknown brand: ${m.groups.brand}`);
+    }
+    const assetDesc = values(agoricNames.vbankAsset).find(
+      d => d.brand === anyBrand,
+    );
+    if (!assetDesc) {
+      throw makeError(`unknown brand: ${m.groups.brand}`);
+    }
+    const { displayInfo } = assetDesc;
+    if (!displayInfo.decimalPlaces || displayInfo.assetKind !== 'nat') {
+      throw makeError(`bad brand: ${displayInfo}`);
+    }
+    const value = BigInt(
+      Number(m.groups.value.replace(/_/g, '')) *
+        10 ** displayInfo.decimalPlaces,
+    );
+    /** @type {Brand<'nat'>} */
+    // @ts-expect-error dynamic cast
+    const natBrand = anyBrand;
+    const amt = { value, brand: natBrand };
+    return amt;
+  };

package/src/main-publish.js

@@ -15,12 +15,10 @@ const publishMain = async (progname, rawArgs, powers, opts) => {
   const { node: rpcAddress, home: homeDirectory, chainID = 'agoric' } = opts;
 
   if (typeof rpcAddress !== 'string') {
-    throw new Error(
-      `Required flag for agoric publish: -n, --node <rpcAddress>`,
-    );
+    throw Error(`Required flag for agoric publish: -n, --node <rpcAddress>`);
   }
   if (typeof homeDirectory !== 'string') {
-    throw new Error(
+    throw Error(
       `Required flag for agoric publish: -h, --home <directory>, containing ag-solo-mnemonic`,
     );
   }
@@ -47,7 +45,7 @@ const publishMain = async (progname, rawArgs, powers, opts) => {
     });
     const publishBundle = makeBundlePublisher({
       getDefaultConnection() {
-        throw new Error(
+        throw Error(
           'Invariant: publishBundle will never call getDefaultConnection because we provide an explicit connectionSpec',
         );
       },