@agoric/deploy-script-support 0.10.4-other-dev-8f8782b.0 → 0.10.4-other-dev-fbe72e7.0.fbe72e7

package/src/permissioned-deployment.js

@@ -0,0 +1,168 @@
+/**
+ * @file support for Contract Deployment Process
+ *
+ * 1. `agoric run XYZ.build.js` produces:
+ *    - `b1-123.json` bundle x 2: contract, aux
+ *    - `XYZ-permit.json`, `XYZ.js` script
+ * 2. Install bundles
+ *    - permissionless with per-byte fee in IST
+ * 3. Submit CoreEval proposal to BLD stakers
+ *    - `XYZ-permit.json`, `XYZ.js`
+ *
+ * @see {runBuilder}
+ * @see {installBundles}
+ * @see {submitCoreEval}
+ */
+import { toCLIOptions } from '@agoric/internal/src/cli-utils.js';
+
+/**
+ * @import {CmdRunner} from '@agoric/pola-io';
+ * @import {FileRd} from '@agoric/pola-io';
+ */
+
+/**
+ *
+ * TODO: builder should be a FileRd
+ * TODO: parameterize dest dir
+ *
+ * @example
+ * to use npx to find `agoric` in node_modules/.bin:
+ *   const execP = promisify(childProcess.execFile)
+ *   const agoric = makeCmdRunner('npx', { execFile: execP }).subCommand('agoric');
+ *
+ * XXX use a different name from execFile since the meaning is different
+ *
+ * @param {CmdRunner} agoric
+ * @param {FileRd} builder
+ * @param {string[]} [builderOpts]
+ * @param {{cwd?: FileRd}} [io]
+ *
+ * @returns {Promise<Plan>}
+ *
+ * @typedef {{
+ *   name: string,
+ *   script: string,
+ *   permit: string,
+ *   bundles: { entrypoint:string, bundleID:string, fileName:string}[];
+ * }} Plan
+ */
+export const runBuilder = async (
+  agoric,
+  builder,
+  builderOpts = [],
+  { cwd = builder.join('../../') } = {},
+) => {
+  const cmd = agoric.withFlags(...builderOpts);
+  const { stdout } = await cmd.exec(['run', String(builder)]);
+  const match = stdout?.match(/ (?<name>[-\w]+)-permit.json/);
+  if (!(match && match.groups)) {
+    throw Error('no permit found');
+  }
+  /** @type {Plan} */
+  const plan = await cwd.join(`${match.groups.name}-plan.json`).readJSON();
+  return plan;
+};
+
+export const txFlags = ({
+  node,
+  from,
+  chainId,
+  keyringBackend = 'test',
+  broadcastMode = 'block',
+}) => ({
+  node,
+  from,
+  'chain-id': chainId,
+  'keyring-backend': keyringBackend,
+  'broadcast-mode': broadcastMode,
+  // TODO: parameterize these?
+  gas: 'auto',
+  'gas-adjustment': '1.4',
+});
+
+/**
+ * @param {CmdRunner} agd
+ * @param {number} n
+ */
+export const waitForBlock = async (agd, n = 1) => {
+  const getHeight = async () => {
+    const { stdout } = await agd.exec(['status']);
+    const status = JSON.parse(stdout);
+    const { latest_block_height: height } = status.sync_info || status.SyncInfo;
+    return height;
+  };
+  const initialHeight = await getHeight();
+  const SEC = 1000;
+  let currentHeight;
+  do {
+    await new Promise(resolve => setTimeout(resolve, 1 * SEC)); // XXX ambient
+    currentHeight = await getHeight();
+  } while (currentHeight - initialHeight < n);
+  console.log('block height:', initialHeight, currentHeight);
+};
+
+/**
+ * @param {CmdRunner} agd - agd with --from etc.
+ * @param {string[]} txArgs
+ */
+export const runTx = async (agd, txArgs) => {
+  const { stdout } = await agd.withFlags('-o', 'json').exec(['tx', ...txArgs]);
+  const result = JSON.parse(stdout);
+  if (result.code !== 0) {
+    throw Object.assign(Error(result.raw_log), result);
+  }
+  return result;
+};
+
+/**
+ * @param {CmdRunner} agd
+ * @param {FileRd} bundle
+ */
+export const installBundle = async (agd, bundle) =>
+  runTx(agd, ['swingset', 'install-bundle', `@${bundle}`]);
+
+export const txAbbr = tx => {
+  const { txhash, code, height, gas_used: g } = tx;
+
+  return { txhash, code, height, gas_used: g };
+};
+
+/**
+ * @param {CmdRunner} agd
+ * @param {Plan['bundles']} bundles
+ * @param {FileRd} files
+ */
+export const installBundles = (agd, bundles, files) => {
+  const ps = bundles.map(b =>
+    installBundle(agd, files.join(files.relative(b.fileName))),
+  );
+  return Promise.all(ps);
+};
+
+/**
+ * @param {CmdRunner} agd
+ * @param {Pick<Plan, 'permit' | 'script'>[]} evals
+ * @param {object} [opts]
+ * @param {string} [opts.title]
+ * @param {string} [opts.description]
+ * @param {object} [opts.depositOpts]
+ * @param {string} [opts.depositOpts.denom]
+ * @param {number} [opts.depositOpts.unit]
+ * @param {number} [opts.depositOpts.qty]
+ * @param {string} [opts.deposit]
+ */
+export const submitCoreEval = async (
+  agd,
+  evals,
+  {
+    title = evals[0].script,
+    description = title,
+    depositOpts: { denom = 'ubld', unit = 1_000_000, qty = 10 } = {},
+    deposit = `${qty * unit}${denom}`,
+  } = {},
+) =>
+  runTx(agd, [
+    ...'gov submit-proposal swingset-core-eval'.split(' '),
+    ...evals.map(e => [e.permit, e.script]).flat(),
+    ...toCLIOptions({ title, description, deposit }),
+  ]);

package/src/saveIssuer.js

@@ -1,12 +1,15 @@
 // @ts-check
 import { E } from '@endo/far';
 
-/** @typedef {import('@agoric/deploy-script-support/src/externalTypes').Petname} Petname */
+/**
+ * @import {Petname} from '@agoric/deploy-script-support/src/externalTypes.js';
+ * @import {Amount, Brand, Issuer, Payment} from '@agoric/ertp';
+ */
 
 /**
  * @param {ERef<any>} walletAdmin - an internal type of the
  * wallet, not defined here
- * @param {ERef<import('./startInstance').IssuerManager>} issuerManager
+ * @param {ERef<import('./startInstance.js').IssuerManager>} issuerManager
  */
 export const makeSaveIssuer = (walletAdmin, issuerManager) => {
   /**

package/src/startInstance.js

@@ -1,8 +1,12 @@
 // @ts-check
-import { assert } from '@agoric/assert';
+import { assert } from '@endo/errors';
 import { E, passStyleOf } from '@endo/far';
 
-/** @typedef {import('@agoric/deploy-script-support/src/externalTypes').Petname} Petname */
+/**
+ * @import {Petname} from '@agoric/deploy-script-support/src/externalTypes.js';
+ * @import {Amount, Brand, Issuer, Payment, Purse} from '@agoric/ertp';
+ * @import {IssuerKeywordRecord, Keyword} from '@agoric/zoe';
+ */
 
 /**
  * @template T
@@ -100,9 +104,8 @@ export const makeStartInstance = (
         `creatorInvitation must be defined to be deposited`,
       );
       console.log(`-- Adding Invitation for: ${instancePetname}`);
-      const invitationAmount = await E(zoeInvitationPurse).deposit(
-        creatorInvitation,
-      );
+      const invitationAmount =
+        await E(zoeInvitationPurse).deposit(creatorInvitation);
       console.log(`- Created Contract Instance: ${instancePetname}`);
 
       const creatorInvitationDetails = invitationAmount.value[0];

package/src/writeCoreEvalParts.js

@@ -0,0 +1,228 @@
+// @ts-check
+import fs from 'fs';
+import { E } from '@endo/far';
+import { deeplyFulfilled } from '@endo/marshal';
+
+import { createBundles } from '@agoric/internal/src/node/createBundles.js';
+import { defangAndTrim, mergePermits, stringify } from './code-gen.js';
+import {
+  makeCoreProposalBehavior,
+  permits as defaultPermits,
+} from './coreProposalBehavior.js';
+
+/**
+ * @import {BundleSource, BundleSourceResult} from '@endo/bundle-source';
+ * @import {AgSoloHome, CanonicalHome, CommonHome, CoreEvalBuilder, CoreEvalDescriptor, ManifestBundleRef} from './externalTypes.js';
+ */
+
+/**
+ * @typedef CoreEvalPlan
+ * @property {string} name
+ * @property {string} permit
+ * @property {string} script
+ * @property {{entrypoint: string, bundleID: string, fileName: string}[]} bundles
+ */
+
+/**
+ * @callback WriteCoreEval write to disk the files needed for a CoreEval (js code to`${filePrefix}.js`, permits to `${filePrefix}-permit.json`, an overall
+ *   summary to `${filePrefix}-plan.json), plus whatever bundles bundles the code loads)
+ * see CoreEval in {@link '/golang/cosmos/x/swingset/types/swingset.pb.go'}
+ * @param {string} filePrefix name on disk
+ * @param {CoreEvalBuilder} builder
+ * @returns {Promise<CoreEvalPlan>}
+ */
+
+/**
+ *
+ * @param {Promise<CommonHome | AgSoloHome>} homeP
+ * @param {{
+ *   bundleSource: BundleSource,
+ *   pathResolve: (path: string) => string,
+ * }} endowments
+ * @param {{
+ *   getBundlerMaker: () => Promise<import('./getBundlerMaker.js').BundleMaker>,
+ *   getBundleSpec: (bundle: Promise<BundleSourceResult<'endoZipBase64'>>, getBundle: () => import('./getBundlerMaker.js').Bundler, opts?: any) => Promise<ManifestBundleRef>,
+ *   log?: typeof console.log,
+ *   writeFile?: typeof fs.promises.writeFile
+ * }} io
+ * @returns {WriteCoreEval}
+ */
+export const makeWriteCoreEval = (
+  homeP,
+  endowments,
+  {
+    getBundlerMaker,
+    getBundleSpec,
+    log = console.log,
+    writeFile = fs.promises.writeFile,
+  },
+) => {
+  const { bundleSource, pathResolve } = endowments;
+
+  let bundlerCache;
+  /** @returns {import('./getBundlerMaker.js').Bundler} */
+  const getBundler = () => {
+    if (!bundlerCache) {
+      bundlerCache = E(getBundlerMaker()).makeBundler({
+        // @ts-expect-error lazily resolved for AgSoloHome
+        zoe: E.get(homeP).zoe,
+      });
+    }
+    return bundlerCache;
+  };
+
+  /**
+   *
+   * @param {CoreEvalDescriptor} coreEval
+   * @param {*} additionalPermits
+   */
+  const mergeEvalPermit = async (coreEval, additionalPermits) => {
+    const {
+      sourceSpec,
+      getManifestCall: [manifestGetterName, ...manifestGetterArgs],
+    } = coreEval;
+
+    const moduleNamespace = await import(pathResolve(sourceSpec));
+
+    // We only care about the manifest, not any restoreRef calls.
+    const { manifest } = await moduleNamespace[manifestGetterName](
+      harden({ restoreRef: x => `restoreRef:${x}` }),
+      ...manifestGetterArgs,
+    );
+
+    const mergedPermits = mergePermits(manifest);
+    return {
+      manifest,
+      permits: mergePermits({ mergedPermits, additionalPermits }),
+    };
+  };
+
+  let mutex = /** @type {Promise<ManifestBundleRef | undefined>} */ (
+    Promise.resolve()
+  );
+  /** @type {WriteCoreEval} */
+  const writeCoreEval = async (filePrefix, builder) => {
+    /**
+     *
+     * @param {string} entrypoint
+     * @param {string} [bundlePath]
+     * @returns {Promise<BundleSourceResult<'endoZipBase64'>>}
+     */
+    const getBundle = async (entrypoint, bundlePath) => {
+      if (!bundlePath) {
+        return bundleSource(pathResolve(entrypoint));
+      }
+      const bundleCache = pathResolve(bundlePath);
+      await createBundles([[pathResolve(entrypoint), bundleCache]]);
+      const ns = await import(bundleCache);
+      return ns.default;
+    };
+
+    const bundles = [];
+
+    /**
+     * Install an entrypoint.
+     *
+     * @param {string} entrypoint
+     * @param {string} [bundlePath]
+     * @param {unknown} [opts]
+     * @returns {Promise<ManifestBundleRef>}
+     */
+    const install = async (entrypoint, bundlePath, opts) => {
+      const bundle = getBundle(entrypoint, bundlePath);
+
+      // Serialise the installations.
+      mutex = E.when(mutex, async () => {
+        // console.log('installing', { filePrefix, entrypoint, bundlePath });
+        const spec = await getBundleSpec(bundle, getBundler, opts);
+        bundles.push({
+          entrypoint,
+          ...spec,
+        });
+        return spec;
+      });
+      // @ts-expect-error xxx mutex type narrowing
+      return mutex;
+    };
+
+    // Await a reference then publish to the board.
+    const cmds = [];
+    /** @param {Promise<ManifestBundleRef>} refP */
+    const publishRef = async refP => {
+      const { fileName, ...ref } = await refP;
+      if (fileName) {
+        cmds.push(`agd tx swingset install-bundle @${fileName}`);
+      }
+
+      return harden(ref);
+    };
+
+    // Create the eval structure.
+    const evalDescriptor = await deeplyFulfilled(
+      harden(builder({ publishRef, install })),
+    );
+    const { sourceSpec, getManifestCall } = evalDescriptor;
+    // console.log('created', { filePrefix, sourceSpec, getManifestCall });
+
+    // Extract the top-level permit.
+    const { permits: evalPermits, manifest: customManifest } =
+      await mergeEvalPermit(evalDescriptor, defaultPermits);
+
+    // Get an install
+    const manifestBundleRef = await publishRef(install(sourceSpec));
+
+    // console.log('writing', { filePrefix, manifestBundleRef, sourceSpec });
+    const code = `\
+// This is generated by writeCoreEval; please edit!
+/* eslint-disable */
+
+const manifestBundleRef = ${stringify(manifestBundleRef)};
+const getManifestCall = harden(${stringify(getManifestCall, true)});
+const customManifest = ${stringify(customManifest, true)};
+
+// Make a behavior function and "export" it by way of script completion value.
+// It is constructed by an anonymous invocation to ensure the absence of a global binding
+// for makeCoreProposalBehavior, which may not be necessary but preserves behavior pre-dating
+// https://github.com/Agoric/agoric-sdk/pull/8712 .
+const behavior = (${makeCoreProposalBehavior})({ manifestBundleRef, getManifestCall, customManifest, E });
+behavior;
+`;
+
+    const trimmed = defangAndTrim(code);
+
+    const permitFile = `${filePrefix}-permit.json`;
+    log(`creating ${permitFile}`);
+    await writeFile(permitFile, JSON.stringify(evalPermits, null, 2));
+
+    const codeFile = `${filePrefix}.js`;
+    log(`creating ${codeFile}`);
+    await writeFile(codeFile, trimmed);
+
+    /** @type {CoreEvalPlan} */
+    const plan = {
+      name: filePrefix,
+      script: codeFile,
+      permit: permitFile,
+      bundles,
+    };
+
+    await writeFile(
+      `${filePrefix}-plan.json`,
+      `${JSON.stringify(plan, null, 2)}\n`,
+    );
+
+    log(`\
+You can now run a governance submission command like:
+  agd tx gov submit-proposal swingset-core-eval ${permitFile} ${codeFile} \\
+    --title="Enable <something>" --description="Evaluate ${codeFile}" --deposit=1000000ubld \\
+    --gas=auto --gas-adjustment=1.2
+Remember to install bundles before submitting the proposal:
+  ${cmds.join('\n  ')}
+`);
+    return plan;
+  };
+
+  return writeCoreEval;
+};
+/** @deprecated use makeWriteCoreEval */
+export const makeWriteCoreProposal = makeWriteCoreEval;