agoric 0.18.4 → 0.18.5-dev-800c2bb.0

package/src/main.js

@@ -2,6 +2,7 @@
 /* global process */
 import { Command } from 'commander';
 import path from 'path';
+import url from 'url';
 import { assert, details as X } from '@agoric/assert';
 import {
   DEFAULT_KEEP_POLLING_SECONDS,
@@ -9,6 +10,7 @@ import {
 } from '@agoric/casting';
 import cosmosMain from './cosmos.js';
 import deployMain from './deploy.js';
+import runMain from './run.js';
 import publishMain from './main-publish.js';
 import initMain from './init.js';
 import installMain from './install.js';
@@ -24,7 +26,7 @@ const DEFAULT_DAPP_BRANCH = undefined;
 
 const STAMP = '_agstate';
 
-const filename = new URL(import.meta.url).pathname;
+const filename = url.fileURLToPath(import.meta.url);
 const dirname = path.dirname(filename);
 
 const main = async (progname, rawArgs, powers) => {
@@ -51,9 +53,7 @@ const main = async (progname, rawArgs, powers) => {
     );
   }
 
-  program.storeOptionsAsProperties(false);
-
-  const pj = await fs.readFile(`${dirname}/../package.json`);
+  const pj = await fs.readFile(path.join(dirname, '..', 'package.json'));
   const pkg = JSON.parse(pj);
   program.name(pkg.name).version(pkg.version);
 
@@ -72,11 +72,24 @@ const main = async (progname, rawArgs, powers) => {
   program
     .command('cosmos <command...>')
     .description('client for an Agoric Cosmos chain')
-    .action(async (command, cmd) => {
+    .action(async (command, _options, cmd) => {
       const opts = { ...program.opts(), ...cmd.opts() };
       return subMain(cosmosMain, ['cosmos', ...command], opts);
     });
 
+  const ibcSetup = path.join(
+    dirname,
+    '..',
+    'node_modules',
+    '.bin',
+    'ibc-setup',
+  );
+  program.command(
+    'ibc-setup <command...>',
+    'set up Inter Blockchain Communication',
+    { executableFile: ibcSetup },
+  );
+
   program
     .command('open')
     .description('launch the Agoric UI')
@@ -98,7 +111,7 @@ const main = async (progname, rawArgs, powers) => {
         return value;
       },
     )
-    .action(async cmd => {
+    .action(async (_options, cmd) => {
       const opts = { ...program.opts(), ...cmd.opts() };
       return subMain(walletMain, ['wallet'], opts);
     });
@@ -121,7 +134,7 @@ const main = async (progname, rawArgs, powers) => {
       'use this branch instead of the repository HEAD',
       DEFAULT_DAPP_BRANCH,
     )
-    .action(async (project, cmd) => {
+    .action(async (project, _options, cmd) => {
       const opts = { ...program.opts(), ...cmd.opts() };
       return subMain(initMain, ['init', project], opts);
     });
@@ -154,15 +167,30 @@ const main = async (progname, rawArgs, powers) => {
       'set the config.toml p2p.unconditional_peer_ids value',
       '',
     )
-    .action(async (prog, configDir, cmd) => {
+    .action(async (prog, configDir, _options, cmd) => {
       const opts = { ...program.opts(), ...cmd.opts() };
       return subMain(setDefaultsMain, ['set-defaults', prog, configDir], opts);
     });
 
+  const ibcRelayer = path.join(
+    dirname,
+    '..',
+    'node_modules',
+    '.bin',
+    'ibc-relayer',
+  );
+  program.command(
+    'ibc-relayer',
+    'run an Inter Blockchain Communications relayer',
+    {
+      executableFile: ibcRelayer,
+    },
+  );
+
   program
     .command('install [force-sdk-version]')
     .description('install Dapp dependencies')
-    .action(async (forceSdkVersion, cmd) => {
+    .action(async (forceSdkVersion, _options, cmd) => {
       await isNotBasedir();
       const opts = { ...program.opts(), ...cmd.opts() };
       return subMain(installMain, ['install', forceSdkVersion], opts);
@@ -204,6 +232,10 @@ const main = async (progname, rawArgs, powers) => {
       },
       DEFAULT_JITTER_SECONDS,
     )
+    .option(
+      '-F, --first-value-only',
+      'only display the first value of each <path-spec>',
+    )
     .option(
       '-o, --output <format>',
       'value output format',
@@ -237,7 +269,7 @@ const main = async (progname, rawArgs, powers) => {
       'show current block height when each value is reported',
     )
     .option('-B, --bootstrap <config>', 'network bootstrap configuration')
-    .action(async (pathSpecs, cmd) => {
+    .action(async (pathSpecs, _options, cmd) => {
       const opts = { ...program.opts(), ...cmd.opts() };
       return subMain(followMain, ['follow', ...pathSpecs], opts);
     });
@@ -265,16 +297,15 @@ const main = async (progname, rawArgs, powers) => {
         '',
       );
 
-  addRunOptions(
-    program
-      .command('run <script> [script-args...]')
-      .description(
-        'run a script with all your user privileges against the local Agoric VM',
-      ),
-  ).action(async (script, scriptArgs, cmd) => {
-    const opts = { ...program.opts(), ...cmd.opts(), scriptArgs };
-    return subMain(deployMain, ['run', script], opts);
-  });
+  program
+    .command('run <script> [script-args...]')
+    .description(
+      'run a script with all your user privileges and some Agoric endowments',
+    )
+    .action(async (script, scriptArgs, _options, cmd) => {
+      const opts = { ...program.opts(), ...cmd.opts(), scriptArgs };
+      return subMain(runMain, ['run', script], opts);
+    });
 
   addRunOptions(
     program
@@ -287,31 +318,32 @@ const main = async (progname, rawArgs, powers) => {
       .description(
         'run multiple scripts with all your user privileges against the local Agoric VM',
       ),
-  ).action(async (scripts, cmd) => {
+  ).action(async (scripts, _options, cmd) => {
     const opts = { ...program.opts(), ...cmd.opts() };
     return subMain(deployMain, ['deploy', ...scripts], opts);
   });
 
-  addRunOptions(
-    program
-      .command('publish [bundle...]')
-      .option(
-        '-n, --node <rpcAddress>',
-        '[required] A bare IPv4 address or fully qualified URL of an RPC node',
-      )
-      .option(
-        '-h, --home <directory>',
-        "[required] Path to the directory containing ag-solo-mnemonic, for the publisher's wallet mnemonic",
-      )
-      .option(
-        '-c, --chain-id <chainID>',
-        'The ID of the destination chain, if not simply "agoric"',
-      )
-      .description('publish a bundle to a Cosmos chain'),
-  ).action(async (bundles, cmd) => {
-    const opts = { ...program.opts(), ...cmd.opts() };
-    return subMain(publishMain, ['publish', ...bundles], opts);
-  });
+  program
+    .command('publish [bundle...]')
+    .option(
+      '-c, --chain-id <chainID>',
+      'The ID of the destination chain',
+      'agoriclocal',
+    )
+    .option(
+      '-n, --node <rpcAddress>',
+      'A bare IPv4 address or fully qualified URL of an RPC node',
+      'http://localhost:26657',
+    )
+    .option(
+      '-h, --home <directory>',
+      "[required] Path to the directory containing ag-solo-mnemonic, for the publisher's wallet mnemonic",
+    )
+    .description('publish a bundle to a Cosmos chain')
+    .action(async (bundles, _options, cmd) => {
+      const opts = { ...program.opts(), ...cmd.opts() };
+      return subMain(publishMain, ['publish', ...bundles], opts);
+    });
 
   program.addCommand(await makeWalletCommand());
 
@@ -349,7 +381,7 @@ agoric start local-solo [portNum] [provisionPowers] - local solo VM
       'install the wallet from NPM package <package>',
       '@agoric/wallet-frontend',
     )
-    .action(async (profile, args, cmd) => {
+    .action(async (profile, args, _options, cmd) => {
       await isNotBasedir();
       const opts = { ...program.opts(), ...cmd.opts() };
       return subMain(startMain, ['start', profile, ...args], opts);

package/src/open.js

@@ -53,8 +53,10 @@ export default async function walletMain(progname, rawArgs, powers, opts) {
   }${suffix}#accessToken=${encodeURIComponent(walletAccessToken)}`;
 
   process.stdout.write(`${walletUrl}\n`);
+  let p;
   if (opts.browser) {
     const browser = opener(walletUrl);
-    await new Promise(resolve => browser.on('exit', resolve));
+    p = new Promise(resolve => browser.on('exit', resolve));
   }
+  await p;
 }

package/src/publish.js

@@ -13,7 +13,7 @@ import { DirectSecp256k1HdWallet, Registry } from '@cosmjs/proto-signing';
 import { defaultRegistryTypes } from '@cosmjs/stargate';
 import { stringToPath } from '@cosmjs/crypto';
 import { Decimal } from '@cosmjs/math';
-import { Bech32 } from '@cosmjs/encoding';
+import { fromBech32 } from '@cosmjs/encoding';
 
 import { MsgInstallBundle } from '@agoric/cosmic-proto/swingset/msgs.js';
 
@@ -82,7 +82,7 @@ const registry = new Registry([
  * @typedef {SourceBundle | HashBundle} Bundle
  */
 
-const { details: X, quote: q } = assert;
+const { details: X, quote: q, Fail } = assert;
 
 /**
  * @template T
@@ -121,9 +121,7 @@ const assertHttpConnectionSpec = connectionSpec => {
     X`Expected "port" number on "http" type connectionSpec, ${connectionSpec}`,
   );
   Number.isInteger(port) ||
-    assert.fail(
-      X`Expected integer "port" on "http" type connectionSpec, ${connectionSpec}`,
-    );
+    Fail`Expected integer "port" on "http" type connectionSpec, ${connectionSpec}`;
 };
 
 // eslint-disable-next-line jsdoc/require-returns-check
@@ -198,7 +196,9 @@ export const makeHttpBundlePublisher = ({ jsonHttpCall, getAccessToken }) => {
       'object',
       X`Expected JSON object response body, got ${response}`,
     );
-    assert(response, X`Expected non-null response body, got ${response}`);
+    if (!response) {
+      throw Fail`Expected non-null response body, got ${response}`;
+    }
     const { ok } = response;
     if (!ok) {
       const { rej } = response;
@@ -207,7 +207,7 @@ export const makeHttpBundlePublisher = ({ jsonHttpCall, getAccessToken }) => {
         'string',
         X`Expected "rej" property on JSON response body with "ok": false, got ${response}`,
       );
-      throw new Error(
+      throw Error(
         `Cannot publish bundle, HTTP 200 OK, JSON well-formed, but error message from service: ${rej}`,
       );
     }
@@ -253,10 +253,12 @@ export const makeCosmosBundlePublisher = ({
 
     const leader = makeLeaderFromRpcAddresses(rpcAddresses);
 
+    const file = await readFile(
+      pathResolve(homeDirectory, 'ag-solo-mnemonic'),
+      'ascii',
+    );
     // AWAIT
-    const mnemonic = (
-      await readFile(pathResolve(homeDirectory, 'ag-solo-mnemonic'), 'ascii')
-    ).trim();
+    const mnemonic = file.trim();
 
     const wallet = await DirectSecp256k1HdWallet.fromMnemonic(mnemonic, {
       prefix: Agoric.Bech32MainPrefix,
@@ -267,7 +269,7 @@ export const makeCosmosBundlePublisher = ({
 
     const installBundleMsg = {
       bundle: JSON.stringify(bundle),
-      submitter: Bech32.decode(from.address).data,
+      submitter: fromBech32(from.address).data,
     };
 
     /** @type {Array<import('@cosmjs/proto-signing').EncodeObject>} */
@@ -289,7 +291,6 @@ export const makeCosmosBundlePublisher = ({
       // AWAIT
       // eslint-disable-next-line no-await-in-loop,@jessie.js/no-nested-await
       const stargateClient = await connectWithSigner(endpoint, wallet, {
-        prefix: Agoric.Bech32MainPrefix,
         gasPrice: Agoric.gasPrice,
         registry,
       });
@@ -377,7 +378,7 @@ export const makeCosmosBundlePublisher = ({
  * @param {object} powers
  * @param {PublishBundleCosmos} [powers.publishBundleCosmos]
  * @param {PublishBundleHttp} [powers.publishBundleHttp]
- * @param {() => ConnectionSpec} [powers.getDefaultConnection]
+ * @param {() => Promise<ConnectionSpec>} [powers.getDefaultConnection]
  * @returns {Promise<Bundle>}
  */
 const publishBundle = async (
@@ -419,12 +420,11 @@ const publishBundle = async (
       endoZipBase64Sha512,
     });
   }
-  assert(
-    hashBundle !== undefined,
-    X`Unrecognized bundle format ${q(
+  if (hashBundle === undefined) {
+    throw Fail`Unrecognized bundle format ${q(
       moduleFormat,
-    )}, publishBundle supports only "endoZipBase64" with "endoZipBase64Sha512"`,
-  );
+    )}, publishBundle supports only "endoZipBase64" with "endoZipBase64Sha512"`;
+  }
 
   if (connectionSpec === undefined && getDefaultConnection !== undefined) {
     connectionSpec = await getDefaultConnection();
@@ -435,24 +435,25 @@ const publishBundle = async (
     'object',
     X`Expected object for connectionSpec, got ${connectionSpec}`,
   );
-  assert(connectionSpec, X`Expected non-null connectionSpec`);
+  connectionSpec || Fail`Expected non-null connectionSpec`;
   const { type } = connectionSpec;
   assert.typeof(type, 'string', X`Expected string "type" on connectionSpec`);
 
+  let p;
   if (type === 'http') {
     assertHttpConnectionSpec(connectionSpec);
     assert(
       publishBundleHttp,
       'HTTP installation transaction publisher required',
     );
-    await publishBundleHttp(bundle, connectionSpec);
+    p = publishBundleHttp(bundle, connectionSpec);
   } else if (type === 'chain-cosmos-sdk') {
     assertCosmosConnectionSpec(connectionSpec);
     assert(
       publishBundleCosmos,
       'Cosmos SDK installation transaction publisher required',
     );
-    await publishBundleCosmos(bundle, connectionSpec);
+    p = publishBundleCosmos(bundle, connectionSpec);
   } else if (type === 'fake-chain') {
     // For the purposes of submitting a bundle to an API like
     // E(zoe).install(bundle), in the cases where the publication target does
@@ -462,9 +463,10 @@ const publishBundle = async (
     // source bundles in-band.
     return bundle;
   } else {
-    throw new Error(`Unsupported connection type ${type}`);
+    throw Error(`Unsupported connection type ${type}`);
   }
 
+  await p;
   return hashBundle;
 };
 
@@ -474,7 +476,7 @@ const publishBundle = async (
  * @param {(hostPort: string) => Promise<string>} [powers.getAccessToken]
  * @param {PublishBundleCosmos} [powers.publishBundleCosmos]
  * @param {PublishBundleHttp} [powers.publishBundleHttp]
- * @param {() => ConnectionSpec} [powers.getDefaultConnection]
+ * @param {() => Promise<ConnectionSpec>} [powers.getDefaultConnection]
  */
 export const makeBundlePublisher = powers => {
   /**

package/src/run.js

@@ -0,0 +1,20 @@
+import makeScratchPad from '@agoric/internal/src/scratch.js';
+import { makeScriptLoader } from './scripts.js';
+
+export default async function runMain(progname, rawArgs, powers, opts) {
+  const { anylogger, fs, now } = powers;
+  const console = anylogger('agoric:run');
+
+  const endowments = {
+    now,
+    scriptArgs: opts.scriptArgs,
+  };
+  const script = rawArgs[1];
+  const runScript = makeScriptLoader(
+    [script],
+    { progname, rawArgs: [script, ...opts.scriptArgs], endowments },
+    { fs, console },
+  );
+  const homeP = Promise.resolve({ scratch: Promise.resolve(makeScratchPad()) });
+  return runScript({ home: homeP });
+}

package/src/scripts.js

@@ -0,0 +1,190 @@
+// @ts-check
+/* global process */
+import bundleSource from '@endo/bundle-source';
+import { E } from '@endo/captp';
+import { search as readContainingPackageDescriptor } from '@endo/compartment-mapper';
+
+import createEsmRequire from 'esm';
+import { createRequire } from 'module';
+import path from 'path';
+import url from 'url';
+
+const require = createRequire(import.meta.url);
+const esmRequire = createEsmRequire(/** @type {NodeModule} */ ({}));
+
+const PATH_SEP_RE = new RegExp(`${path.sep.replace(/\\/g, '\\\\')}`, 'g');
+
+export const makeLookup =
+  bootP =>
+  /**
+   * Recursively look up names in the context of the bootstrap
+   * promise, such as:
+   *
+   * ['agoricNames', 'oracleBrand', 'USD']
+   * ['namesByAddress']
+   * ['namesByAddress', 'agoric1...']
+   * ['namesByAddress', 'agoric1...', 'depositFacet']
+   * ['wallet', 'issuer', 'IST']
+   *
+   * @param  {string[]} args
+   * @returns {Promise<any>}
+   */
+  (...args) => {
+    /** @type {string[]} */
+    let namePath;
+    if (args.length === 1 && Array.isArray(args[0])) {
+      // Convert single array argument to a path.
+      namePath = args[0];
+    } else {
+      namePath = args;
+    }
+    if (namePath.length === 0) {
+      return bootP;
+    }
+    const [first, ...remaining] = namePath;
+
+    // The first part of the name path is a property on bootP.
+    const nextValue = E.get(bootP)[first];
+    if (remaining.length === 0) {
+      return nextValue;
+    }
+
+    // Any remaining paths go through the lookup method of the found
+    // object.
+    return E(nextValue).lookup(...remaining);
+  };
+
+/**
+ * @param {string[]} scripts
+ * @param {{ allowUnsafePlugins: boolean, progname: string, rawArgs: string[], endowments?: Record<string, any> }} opts
+ * @param {{ fs: import('fs/promises'), console: Console }} powers
+ */
+export const makeScriptLoader =
+  (
+    scripts,
+    { allowUnsafePlugins, progname, rawArgs, endowments },
+    { fs, console },
+  ) =>
+  async ({ home: bootP }) => {
+    const pluginManager = await E.get(E.get(bootP).local).plugin.catch(_ => {});
+    const pluginDir = await E(pluginManager)
+      .getPluginDir()
+      .catch(_ => {});
+
+    if (allowUnsafePlugins && !pluginDir) {
+      throw Error(`Installing unsafe plugins disabled; no pluginDir detected`);
+    }
+
+    for await (const script of scripts) {
+      const moduleFile = path.resolve(process.cwd(), script);
+      const pathResolve = (...paths) => {
+        const fileName = paths.pop();
+        try {
+          return require.resolve(fileName, {
+            paths: [
+              path.resolve(path.dirname(moduleFile), ...paths),
+              path.dirname(moduleFile),
+            ],
+          });
+        } catch (e) {
+          return path.resolve(path.dirname(moduleFile), ...paths, fileName);
+        }
+      };
+      console.warn('running', moduleFile);
+
+      let installUnsafePlugin;
+      if (!allowUnsafePlugins) {
+        installUnsafePlugin = async (plugin, _opts = undefined) => {
+          throw Error(
+            `Installing unsafe plugin ${JSON.stringify(
+              pathResolve(plugin),
+            )} disabled; maybe you meant '--allow-unsafe-plugins'?`,
+          );
+        };
+      } else {
+        installUnsafePlugin = (plugin, pluginOpts = undefined) => {
+          const tryInstallUnsafePlugin = async () => {
+            const absPath = pathResolve(plugin);
+            const pluginName = absPath.replace(PATH_SEP_RE, '_');
+            const pluginFile = path.resolve(pluginDir, pluginName);
+
+            // Just create a little redirector for that path.
+            console.warn(`Installing unsafe plugin ${JSON.stringify(absPath)}`);
+            const content = `\
+// ${pluginFile}
+// AUTOMATICALLY GENERATED BY ${JSON.stringify(
+              [progname, ...rawArgs].join(' '),
+            )}
+export { bootPlugin } from ${JSON.stringify(absPath)};
+`;
+            await fs.writeFile(pluginFile, content);
+
+            // Return the bootstrap object for this plugin.
+            console.info(`Loading plugin ${JSON.stringify(pluginFile)}`);
+            return E.get(E(pluginManager).load(pluginName, pluginOpts))
+              .pluginRoot;
+          };
+          return tryInstallUnsafePlugin().catch(e => {
+            throw Error(`Cannot install unsafe plugin: ${(e && e.stack) || e}`);
+          });
+        };
+      }
+
+      // Use a dynamic import to load the deploy script.
+      // It is unconfined.
+
+      // Use Node.js ESM support if package.json of template says "type":
+      // "module".
+      const read = async location => fs.readFile(url.fileURLToPath(location));
+      const { packageDescriptorText } = await readContainingPackageDescriptor(
+        read,
+        url.pathToFileURL(moduleFile).href,
+      ).catch(cause => {
+        throw Error(
+          `Expected a package.json beside deploy script ${moduleFile}, ${cause}`,
+          { cause },
+        );
+      });
+      const packageDescriptor = JSON.parse(packageDescriptorText);
+      const nativeEsm = packageDescriptor.type === 'module';
+      console.log(
+        `Deploy script will run with ${
+          nativeEsm ? 'Node.js ESM' : 'standardthings/esm emulation'
+        }`,
+      );
+
+      const modulePath = pathResolve(moduleFile);
+      let mainNS = await (nativeEsm && import(modulePath));
+      if (!mainNS) {
+        mainNS = esmRequire(modulePath);
+      }
+
+      const allEndowments = harden({
+        home: bootP,
+        bundleSource: (file, options = undefined) =>
+          bundleSource(pathResolve(file), options),
+        ...endowments,
+        pathResolve,
+        installUnsafePlugin,
+        lookup: makeLookup(bootP),
+      });
+
+      const main = mainNS.main;
+      if (typeof main === 'function') {
+        await main(allEndowments);
+        continue;
+      }
+
+      const defaultMain = mainNS.default;
+      if (typeof defaultMain !== 'function') {
+        console.error(
+          `${moduleFile} does not have an "export main" nor "export default" function`,
+        );
+        continue;
+      }
+
+      // Backward-compatibility: if the module doesn't export 'main', then
+      // assume it has a default export using the old 'deploy' API.
+      await defaultMain(allEndowments.home, allEndowments);
+    }
+  };

package/src/sdk-package-names.js

@@ -10,7 +10,6 @@ export default [
   "@agoric/cosmic-swingset",
   "@agoric/cosmos",
   "@agoric/deploy-script-support",
-  "@agoric/deployment",
   "@agoric/ertp",
   "@agoric/eslint-config",
   "@agoric/governance",
@@ -25,21 +24,26 @@ export default [
   "@agoric/solo",
   "@agoric/sparse-ints",
   "@agoric/spawner",
+  "@agoric/ssh-node",
   "@agoric/stat-logger",
   "@agoric/store",
   "@agoric/swing-store",
+  "@agoric/swingset-liveslots",
   "@agoric/swingset-runner",
   "@agoric/swingset-vat",
+  "@agoric/swingset-xsnap-supervisor",
   "@agoric/telemetry",
+  "@agoric/time",
   "@agoric/ui-components",
   "@agoric/vat-data",
   "@agoric/vats",
   "@agoric/wallet",
   "@agoric/wallet-backend",
   "@agoric/wallet-connection",
-  "@agoric/wallet-ui",
   "@agoric/web-components",
   "@agoric/xsnap",
+  "@agoric/xsnap-lockdown",
   "@agoric/zoe",
+  "@agoric/zone",
   "agoric"
 ];

package/src/set-defaults.js

@@ -1,5 +1,5 @@
 import { basename } from 'path';
-import { assert, details as X } from '@agoric/assert';
+import { Fail } from '@agoric/assert';
 import {
   finishCosmosApp,
   finishTendermintConfig,
@@ -12,7 +12,7 @@ export default async function setDefaultsMain(progname, rawArgs, powers, opts) {
 
   const [prog, configDir] = rawArgs.slice(1);
   prog === 'ag-chain-cosmos' ||
-    assert.fail(X`<prog> must currently be 'ag-chain-cosmos'`);
+    Fail`<prog> must currently be 'ag-chain-cosmos'`;
 
   const { exportMetrics, enableCors } = opts;