agoric 0.18.4 → 0.18.5-dev-800c2bb.0

package/src/follow.js

@@ -1,7 +1,11 @@
 // @ts-check
 import process from 'process';
-import { Far, getInterfaceOf } from '@endo/marshal';
-import { decodeToJustin } from '@endo/marshal/src/marshal-justin.js';
+import {
+  Far,
+  getInterfaceOf,
+  decodeToJustin,
+  makeMarshal,
+} from '@endo/marshal';
 
 import {
   iterateLatest,
@@ -12,11 +16,39 @@ import {
 } from '@agoric/casting';
 import { makeLeaderOptions } from './lib/casting.js';
 
+const makeCapDataToQclass = () => {
+  const valToSlot = new WeakMap();
+  const slotToVal = new Map();
+  const convertValToSlot = val => {
+    return valToSlot.get(val);
+  };
+  const convertSlotToVal = (slot, iface) => {
+    if (slotToVal.has(slot)) {
+      return slotToVal.get(slot);
+    }
+    const debugName = iface.startsWith('Alleged: ')
+      ? iface.slice('Alleged: '.length)
+      : iface;
+    const remotable = Far(debugName, {});
+
+    valToSlot.set(remotable, slot);
+    slotToVal.set(slot, remotable);
+    return remotable;
+  };
+  const { toCapData, fromCapData } = makeMarshal(
+    convertValToSlot,
+    convertSlotToVal,
+  );
+  const capDataToQclass = capdata => toCapData(fromCapData(capdata));
+  return capDataToQclass;
+};
+
 export default async function followerMain(progname, rawArgs, powers, opts) {
   const { anylogger } = powers;
   const console = anylogger('agoric:follower');
 
   const {
+    firstValueOnly,
     proof,
     output,
     bootstrap = 'http://localhost:26657',
@@ -35,11 +67,12 @@ export default async function followerMain(progname, rawArgs, powers, opts) {
   switch (output) {
     case 'justinlines':
     case 'justin': {
+      const capDataToQclass = makeCapDataToQclass();
       followerOptions.unserializer = null;
       const pretty = !output.endsWith('lines');
-      formatOutput = ({ body, slots }) => {
+      formatOutput = capdata => {
+        const { body, slots } = capDataToQclass(capdata);
         const encoded = JSON.parse(body);
-        // @ts-expect-error Expected 1-2 arguments, but got 3.
         return decodeToJustin(encoded, pretty, slots);
       };
       break;
@@ -121,6 +154,9 @@ export default async function followerMain(progname, rawArgs, powers, opts) {
             value,
           )}\n`,
         );
+        if (firstValueOnly) {
+          return;
+        }
       }
     }),
   );

package/src/init.js

@@ -2,8 +2,10 @@ import chalk from 'chalk';
 import { makePspawn } from './helpers.js';
 
 // Ambient types. Needed only for dev but this does a runtime import.
+// https://github.com/Agoric/agoric-sdk/issues/6512
 import '@endo/captp/src/types.js';
 import '@agoric/swingset-vat/exported.js';
+import '@agoric/swingset-vat/src/vats/network/types.js';
 
 // Use either an absolute template URL, or find it relative to DAPP_URL_BASE.
 const gitURL = (relativeOrAbsoluteURL, base) => {
@@ -38,15 +40,14 @@ export default async function initMain(_progname, rawArgs, priv, opts) {
     dappBranch = ['-b', opts.dappBranch];
   }
 
-  if (
-    await pspawn(
-      'git',
-      ['clone', '--origin=upstream', dappURL, DIR, ...dappBranch],
-      {
-        stdio: 'inherit',
-      },
-    )
-  ) {
+  const exitStatus = await pspawn(
+    'git',
+    ['clone', '--origin=upstream', dappURL, DIR, ...dappBranch],
+    {
+      stdio: 'inherit',
+    },
+  );
+  if (exitStatus) {
     throw Error('cannot clone');
   }
 
@@ -55,7 +56,7 @@ export default async function initMain(_progname, rawArgs, priv, opts) {
 
   let topLevelName;
   const subdirs = ['', 'api/', 'contract/', 'ui/', '_agstate/agoric-servers/'];
-  for (const dir of subdirs) {
+  for await (const dir of subdirs) {
     const path = `${DIR}/${dir}package.json`;
     log('rewriting ', path);
 

package/src/install.js

@@ -59,7 +59,7 @@ export default async function installMain(progname, rawArgs, powers, opts) {
   }
 
   const yarnInstallEachWorktree = async (phase, ...flags) => {
-    for (const workTree of workTrees) {
+    for await (const workTree of workTrees) {
       log.info(`yarn install ${phase} in ${workTree}`);
       // eslint-disable-next-line no-await-in-loop
       const yarnInstall = await pspawn(
@@ -226,15 +226,14 @@ export default async function installMain(progname, rawArgs, powers, opts) {
       }
     }
   } else {
+    const subdirPackageJsonExists = async subd => {
+      const exists = await fs.stat(`${subd}/package.json`).catch(_ => false);
+      return exists && subd;
+    };
     const existingSubdirs = await Promise.all(
       ['.', '_agstate/agoric-servers', 'contract', 'api', 'ui']
         .sort()
-        .map(async subd => {
-          const exists = await fs
-            .stat(`${subd}/package.json`)
-            .catch(_ => false);
-          return exists && subd;
-        }),
+        .map(subdirPackageJsonExists),
     );
     subdirs = existingSubdirs.filter(subd => subd);
   }
@@ -254,22 +253,21 @@ export default async function installMain(progname, rawArgs, powers, opts) {
       await fs.symlink(sdkRoot, sdkWorktree);
     }
 
-    await Promise.all(
-      subdirs.map(async subdir => {
-        const nm = `${subdir}/node_modules`;
-        log(chalk.bold.green(`removing ${nm} link`));
-        await fs.unlink(nm).catch(_ => {});
+    const removeNodeModulesSymlinks = async subdir => {
+      const nm = `${subdir}/node_modules`;
+      log(chalk.bold.green(`removing ${nm} link`));
+      await fs.unlink(nm).catch(_ => {});
 
-        // Remove all the package links.
-        // This is needed to prevent yarn errors when installing new versions of
-        // linked modules (like `@agoric/zoe`).
-        await Promise.all(
-          [...sdkPackageToPath.keys()].map(async pjName =>
-            fs.unlink(`${nm}/${pjName}`).catch(_ => {}),
-          ),
-        );
-      }),
-    );
+      // Remove all the package links.
+      // This is needed to prevent yarn errors when installing new versions of
+      // linked modules (like `@agoric/zoe`).
+      await Promise.all(
+        [...sdkPackageToPath.keys()].map(async pjName =>
+          fs.unlink(`${nm}/${pjName}`).catch(_ => {}),
+        ),
+      );
+    };
+    await Promise.all(subdirs.map(removeNodeModulesSymlinks));
   } else {
     DEFAULT_SDK_PACKAGE_NAMES.forEach(name => sdkPackageToPath.set(name, null));
   }
@@ -310,17 +308,14 @@ export default async function installMain(progname, rawArgs, powers, opts) {
   );
 
   const sdkPackages = [...sdkPackageToPath.keys()].sort();
-  for (const subdir of subdirs) {
-    // eslint-disable-next-line no-await-in-loop
+  for await (const subdir of subdirs) {
     const exists = await fs.stat(`${subdir}/package.json`).catch(_ => false);
-    if (
-      exists &&
-      // eslint-disable-next-line no-await-in-loop
-      (await pspawn('yarn', [...linkFlags, 'link', ...sdkPackages], {
+    const exitStatus = await (exists &&
+      pspawn('yarn', [...linkFlags, 'link', ...sdkPackages], {
         stdio: 'inherit',
         cwd: subdir,
-      }))
-    ) {
+      }));
+    if (exitStatus) {
       log.error('Cannot yarn link', ...sdkPackages);
       return 1;
     }

package/src/json-http-client-node.js

@@ -48,14 +48,14 @@ export const makeJsonHttpClient = ({ http }) => {
             const responseBytes = Buffer.concat(chunks);
             const responseText = textDecoder.decode(responseBytes);
             if (response.statusCode !== 200) {
-              throw new Error(`${responseText}`);
+              throw Error(`${responseText}`);
             }
             // May throw: becomes rejection below.
             const responseBody = JSON.parse(responseText);
             resolve(responseBody);
           })().catch(cause => {
             reject(
-              new Error(`JSON HTTP RPC failed with error: ${cause.message}`, {
+              Error(`JSON HTTP RPC failed with error: ${cause.message}`, {
                 cause,
               }),
             );

package/src/json.js

@@ -12,7 +12,7 @@ export const parseLocatedJson = (source, location) => {
     return JSON.parse(source);
   } catch (error) {
     if (error instanceof SyntaxError) {
-      throw new SyntaxError(`Cannot parse JSON from ${location}, ${error}`);
+      throw SyntaxError(`Cannot parse JSON from ${location}, ${error}`);
     }
     throw error;
   }

package/src/lib/casting.js

@@ -3,8 +3,10 @@
 import { delay, exponentialBackoff, randomBackoff } from '@agoric/casting';
 
 // TODO: https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
-/** @param {{log: (...args: any) => void, sleep: number, jitter: number }} config
- * @returns {import('@agoric/casting').LeaderOptions} */
+/**
+ * @param {{log: (...args: any) => void, sleep: number, jitter: number }} config
+ * @returns {import('@agoric/casting').LeaderOptions}
+ */
 export const makeLeaderOptions = ({ log, sleep, jitter }) => {
   return {
     retryCallback: (where, e, attempt) => {

package/src/lib/chain.js

@@ -1,60 +1,174 @@
 // @ts-check
 /* global process */
 import { normalizeBech32 } from '@cosmjs/encoding';
-import { execSync } from 'child_process';
+import { execFileSync as execFileSyncAmbient } from 'child_process';
 
-export const normalizeAddress = literalOrName => {
+const agdBinary = 'agd';
+
+/**
+ * @param {string} literalOrName
+ * @param {{ keyringBackend?: string }} opts
+ * @param {{ execFileSync: typeof execFileSyncAmbient }} [io]
+ */
+export const normalizeAddressWithOptions = (
+  literalOrName,
+  { keyringBackend = undefined } = {},
+  io = { execFileSync: execFileSyncAmbient },
+) => {
   try {
     return normalizeBech32(literalOrName);
   } catch (_) {
     // not an address so try as a key
-    const buff = execSync(`agd keys show --address ${literalOrName}`);
+    const backendOpt = keyringBackend
+      ? [`--keyring-backend=${keyringBackend}`]
+      : [];
+    const buff = io.execFileSync(agdBinary, [
+      `keys`,
+      ...backendOpt,
+      `show`,
+      `--address`,
+      literalOrName,
+    ]);
     return normalizeBech32(buff.toString().trim());
   }
 };
-harden(normalizeAddress);
+harden(normalizeAddressWithOptions);
 
 /**
- * SECURITY: closes over process and child_process
- *
- * @param {string} swingsetArgs
- * @param {import('./rpc').MinimalNetworkConfig} net
- * @param {string} from
- * @param {boolean} [dryRun]
- * @param {{home: string, backend: string}} [keyring]
+ * @param {ReadonlyArray<string>} swingsetArgs
+ * @param {import('./rpc').MinimalNetworkConfig & {
+ *   from: string,
+ *   dryRun?: boolean,
+ *   verbose?: boolean,
+ *   keyring?: {home?: string, backend: string}
+ *   stdout?: Pick<import('stream').Writable, 'write'>
+ *   execFileSync?: typeof import('child_process').execFileSync
+ * }} opts
  */
-export const execSwingsetTransaction = (
-  swingsetArgs,
-  net,
-  from,
-  dryRun = false,
-  keyring = undefined,
-) => {
-  const { chainName, rpcAddrs } = net;
-
-  const homeOpt = keyring?.home ? `--home=${keyring.home}` : '';
+export const execSwingsetTransaction = (swingsetArgs, opts) => {
+  const {
+    from,
+    dryRun = false,
+    verbose = true,
+    keyring = undefined,
+    chainName,
+    rpcAddrs,
+    stdout = process.stdout,
+    execFileSync = execFileSyncAmbient,
+  } = opts;
+  const homeOpt = keyring?.home ? [`--home=${keyring.home}`] : [];
   const backendOpt = keyring?.backend
-    ? `--keyring-backend=${keyring.backend}`
-    : '';
-  const cmd = `agd --node=${rpcAddrs[0]} --chain-id=${chainName} ${homeOpt} ${backendOpt} --from=${from} tx swingset ${swingsetArgs}`;
+    ? [`--keyring-backend=${keyring.backend}`]
+    : [];
+  const cmd = [`--node=${rpcAddrs[0]}`, `--chain-id=${chainName}`].concat(
+    homeOpt,
+    backendOpt,
+    [`--from=${from}`, 'tx', 'swingset'],
+    swingsetArgs,
+  );
 
   if (dryRun) {
-    process.stdout.write('Run this interactive command in shell:\n\n');
-    process.stdout.write(cmd);
-    process.stdout.write('\n');
+    stdout.write(`Run this interactive command in shell:\n\n`);
+    stdout.write(`${agdBinary} `);
+    stdout.write(cmd.join(' '));
+    stdout.write('\n');
   } else {
-    const yesCmd = `${cmd} --yes`;
-    console.log('Executing ', yesCmd);
-    execSync(yesCmd);
+    const yesCmd = cmd.concat(['--yes']);
+    if (verbose) console.log('Executing ', yesCmd);
+    return execFileSync(agdBinary, yesCmd, { encoding: 'utf-8' });
   }
 };
 harden(execSwingsetTransaction);
 
 // xxx rpc should be able to query this by HTTP without shelling out
 export const fetchSwingsetParams = net => {
-  const { chainName, rpcAddrs } = net;
-  const cmd = `agd --node=${rpcAddrs[0]} --chain-id=${chainName} query swingset params --output --json`;
-  const buffer = execSync(cmd);
+  const { chainName, rpcAddrs, execFileSync = execFileSyncAmbient } = net;
+  const cmd = [
+    `--node=${rpcAddrs[0]}`,
+    `--chain-id=${chainName}`,
+    'query',
+    'swingset',
+    'params',
+    '--output',
+    '--json',
+  ];
+  const buffer = execFileSync(agdBinary, cmd);
   return JSON.parse(buffer.toString());
 };
 harden(fetchSwingsetParams);
+
+/**
+ * @param {import('./rpc').MinimalNetworkConfig & {
+ *   execFileSync: typeof import('child_process').execFileSync,
+ *   delay: (ms: number) => Promise<void>,
+ *   period?: number,
+ *   retryMessage?: string,
+ * }} opts
+ * @returns {<T>(l: (b: { time: string, height: string }) => Promise<T>) => Promise<T>}
+ */
+export const pollBlocks = opts => async lookup => {
+  const { execFileSync, delay, rpcAddrs, period = 3 * 1000 } = opts;
+  const { retryMessage } = opts;
+
+  const nodeArgs = [`--node=${rpcAddrs[0]}`];
+
+  await null; // separate sync prologue
+
+  for (;;) {
+    const sTxt = execFileSync(agdBinary, ['status', ...nodeArgs]);
+    const status = JSON.parse(sTxt.toString());
+    const {
+      SyncInfo: { latest_block_time: time, latest_block_height: height },
+    } = status;
+    try {
+      // see await null above
+      // eslint-disable-next-line @jessie.js/no-nested-await, no-await-in-loop
+      const result = await lookup({ time, height });
+      return result;
+    } catch (_err) {
+      console.error(
+        time,
+        retryMessage || 'not in block',
+        height,
+        'retrying...',
+      );
+      // eslint-disable-next-line @jessie.js/no-nested-await, no-await-in-loop
+      await delay(period);
+    }
+  }
+};
+
+/**
+ * @param {string} txhash
+ * @param {import('./rpc').MinimalNetworkConfig & {
+ *   execFileSync: typeof import('child_process').execFileSync,
+ *   delay: (ms: number) => Promise<void>,
+ *   period?: number,
+ * }} opts
+ */
+export const pollTx = async (txhash, opts) => {
+  const { execFileSync, rpcAddrs, chainName } = opts;
+
+  const nodeArgs = [`--node=${rpcAddrs[0]}`];
+  const outJson = ['--output', 'json'];
+
+  const lookup = async () => {
+    const out = execFileSync(
+      agdBinary,
+      [
+        'query',
+        'tx',
+        txhash,
+        `--chain-id=${chainName}`,
+        ...nodeArgs,
+        ...outJson,
+      ],
+      { stdio: ['ignore', 'pipe', 'ignore'] },
+    );
+    // XXX this type is defined in a .proto file somewhere
+    /** @type {{ height: string, txhash: string, code: number, timestamp: string }} */
+    const info = JSON.parse(out.toString());
+    return info;
+  };
+  return pollBlocks({ ...opts, retryMessage: 'tx not in block' })(lookup);
+};

package/src/lib/format.js

@@ -1,14 +1,12 @@
 // @ts-check
-/* eslint-disable @typescript-eslint/prefer-ts-expect-error -- https://github.com/Agoric/agoric-sdk/issues/4620 */
+import { makeBoardRemote } from '@agoric/vats/tools/board-utils.js';
 // eslint-disable-next-line no-unused-vars -- typeof below
 import { makeAgoricNames } from './rpc.js';
 
 // ambient types
-import '@agoric/ertp/src/types.js';
+import '@agoric/ertp/src/types-ambient.js';
 
-/** @typedef {import('@agoric/smart-wallet/src/offers').OfferStatus} OfferStatus */
-
-export const COSMOS_UNIT = 1_000_000n;
+/** @typedef {import('@agoric/vats/tools/board-utils.js').BoardRemote} BoardRemote */
 
 /**
  * Like @endo/nat but coerces
@@ -19,44 +17,55 @@ export const COSMOS_UNIT = 1_000_000n;
 export const Natural = str => {
   const b = BigInt(str);
   if (b < 0) {
-    throw new RangeError(`${b} is negative`);
+    throw RangeError(`${b} is negative`);
   }
   return b;
 };
 
+/**
+ * JSON.stringify replacer to handle bigint
+ *
+ * @param {unknown} k
+ * @param {unknown} v
+ */
+export const bigintReplacer = (k, v) => (typeof v === 'bigint' ? `${v}` : v);
+
+/** @type {import('@agoric/vats/tools/board-utils.js').VBankAssetDetail} */
 // eslint-disable-next-line no-unused-vars
 const exampleAsset = {
-  brand: { boardId: 'board0425', iface: 'Alleged: BLD brand' },
+  // @ts-expect-error cast
+  brand: makeBoardRemote({ boardId: 'board0425', iface: 'Alleged: BLD brand' }),
   displayInfo: { assetKind: 'nat', decimalPlaces: 6 },
-  issuer: { boardId: null, iface: undefined },
+  // @ts-expect-error cast
+  issuer: makeBoardRemote({ boardId: null, iface: undefined }),
   petname: 'Agoric staking token',
 };
-/** @typedef {import('@agoric/smart-wallet/src/smartWallet').BrandDescriptor & {brand: import('./rpc').RpcRemote}} AssetDescriptor */
+/** @typedef {import('@agoric/vats/tools/board-utils.js').VBankAssetDetail } AssetDescriptor */
 
-/** @param {AssetDescriptor[]} assets */
+/**
+ * @param {AssetDescriptor[]} assets
+ * @returns {(a: Amount & { brand: BoardRemote }) => [string, number | any[]]}
+ */
 export const makeAmountFormatter = assets => amt => {
+  const { brand, value } = amt;
+  const boardId = brand.getBoardId();
+  const asset = assets.find(a => a.brand.getBoardId() === boardId);
+  if (!asset) return [boardId, Number(value)]; // don't crash
   const {
-    brand: { boardId },
-    value,
-  } = amt;
-  const asset = assets.find(a => a.brand.boardId === boardId);
-  if (!asset) return [NaN, boardId];
-  const {
-    petname,
     displayInfo: { assetKind, decimalPlaces = 0 },
+    issuerName,
   } = asset;
-  const name = Array.isArray(petname) ? petname.join('.') : petname;
   switch (assetKind) {
     case 'nat':
-      /** @type {[petname: string, qty: number]} */
-      return [name, Number(value) / 10 ** decimalPlaces];
+      return [issuerName, Number(value) / 10 ** decimalPlaces];
     case 'set':
+      assert(Array.isArray(value));
       if (value[0]?.handle?.iface?.includes('InvitationHandle')) {
-        return [name, value.map(v => v.description)];
+        return [issuerName, value.map(v => v.description)];
       }
-      return [name, value];
+      return [issuerName, value];
     default:
-      return [name, ['?']];
+      return [issuerName, [NaN]];
   }
 };
 
@@ -66,15 +75,31 @@ export const asPercent = ratio => {
   return (100 * Number(numerator.value)) / Number(denominator.value);
 };
 
+const { Fail, quote: q } = assert;
+
+const isObject = x => typeof x === 'object' && x !== null;
+
+/**
+ * @param {Amount} x
+ * @returns {Amount & { brand: BoardRemote }}
+ */
+export const asBoardRemote = x => {
+  isObject(x) || Fail`not object: ${q(x)}`;
+  isObject(x.brand) || Fail`not object: ${q(x.brand)}`;
+  'getBoardId' in x.brand || Fail`missing getBoardId: ${q(x.brand)}`;
+  // @ts-expect-error dynamic check
+  return x;
+};
+
 /**
  * Summarize the balances array as user-facing informative tuples
- 
+ *
  * @param {import('@agoric/smart-wallet/src/smartWallet').CurrentWalletRecord['purses']} purses
  * @param {AssetDescriptor[]} assets
  */
 export const purseBalanceTuples = (purses, assets) => {
   const fmt = makeAmountFormatter(assets);
-  return purses.map(b => fmt(b.balance));
+  return purses.map(b => fmt(asBoardRemote(b.balance)));
 };
 
 /**
@@ -100,12 +125,8 @@ export const fmtRecordOfLines = record => {
  * @param {Awaited<ReturnType<typeof makeAgoricNames>>} agoricNames
  */
 export const offerStatusTuples = (state, agoricNames) => {
-  const { brands, offerStatuses } = state;
-  const fmt = makeAmountFormatter(
-    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error -- https://github.com/Agoric/agoric-sdk/issues/4620 */
-    // @ts-ignore xxx RpcRemote
-    [...brands.values()],
-  );
+  const { offerStatuses } = state;
+  const fmt = makeAmountFormatter(Object.values(agoricNames.vbankAsset));
   const fmtRecord = r =>
     r
       ? Object.fromEntries(
@@ -116,9 +137,10 @@ export const offerStatusTuples = (state, agoricNames) => {
     assert(o);
     let when = '??';
     try {
-      when = new Date(o.id).toISOString();
+      const timestamp = String(o.id).replace(/\D+/g, '');
+      when = new Date(Number(timestamp)).toISOString();
     } catch {
-      console.debug('offer id', o.id, 'not a timestamp');
+      console.debug('offer id', o.id, 'does not contain a timestamp');
     }
     const {
       proposal: { give, want },
@@ -136,7 +158,6 @@ export const offerStatusTuples = (state, agoricNames) => {
         } = o;
         // xxx could be O(1)
         const entry = Object.entries(agoricNames.instance).find(
-          // @ts-ignore minimarshal types are off by a bit
           ([_name, candidate]) => candidate === instance,
         );
         const instanceName = entry ? entry[0] : '???';
@@ -156,27 +177,21 @@ export const offerStatusTuples = (state, agoricNames) => {
 };
 
 /**
- *
  * @param {import('@agoric/smart-wallet/src/smartWallet').CurrentWalletRecord} current
  * @param {ReturnType<import('@agoric/smart-wallet/src/utils.js').makeWalletStateCoalescer>['state']} coalesced
  * @param {Awaited<ReturnType<typeof makeAgoricNames>>} agoricNames
  */
 export const summarize = (current, coalesced, agoricNames) => {
   return {
-    lastOfferId: [current.lastOfferId],
     purses: purseBalanceTuples(
-      // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error -- https://github.com/Agoric/agoric-sdk/issues/4620 */
-      // @ts-ignore xxx RpcRemote
       [...current.purses.values()],
-      // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error -- https://github.com/Agoric/agoric-sdk/issues/4620 */
-      // @ts-ignore xxx RpcRemote
-      [...current.brands.values()],
+      Object.values(agoricNames.vbankAsset),
     ),
-    usedInvitations: Object.entries(current.offerToUsedInvitation).map(
+    usedInvitations: current.offerToUsedInvitation.map(
       ([offerId, invitationAmt]) => [
         agoricNames.reverse[invitationAmt.value[0].instance.boardId],
         invitationAmt.value[0].description,
-        Number(offerId),
+        offerId,
       ],
     ),
     offers: offerStatusTuples(coalesced, agoricNames),