feat: separate genesis from RUN protocol installation

packages/cosmic-swingset/Makefile

@@ -150,7 +150,7 @@ scenario2-run-client: t1-provision-one-with-powers t1-start-ag-solo
 
 # Provision the ag-solo from an provisionpass-holding address (idempotent).
 AGORIC_POWERS = agoric.ALL_THE_POWERS
-SOLO_COINS = 13000000ubld,50000000urun
+SOLO_COINS = 13000000ubld,1234000000urun
 COSMOS_RPC_HOST = localhost
 COSMOS_RPC_PORT = 26657
 wait-for-cosmos:

packages/deploy-script-support/package.json

@@ -45,6 +45,7 @@
     "@endo/base64": "^0.2.25",
     "@endo/bundle-source": "^2.2.0",
     "@endo/far": "^0.2.3",
+    "@endo/marshal": "^0.6.7",
     "@endo/promise-kit": "^0.2.41",
     "@endo/zip": "^0.2.25"
   },

packages/deploy-script-support/src/coreProposalBehavior.js

@@ -0,0 +1,86 @@
+/**
+ * Create a behavior for a core-eval proposal.
+ *
+ * We rely on directly stringifying this function to leverage our JS toolchain
+ * for catching bugs.  Thus, this maker must not reference any other modules or
+ * definitions.
+ *
+ * @param {object} opts
+ * @param {string} opts.manifestInstallRef
+ * @param {[string, ...unknown[]]} opts.getManifestCall
+ * @param {typeof import('@endo/far').E} opts.E
+ * @param {(...args: unknown[]) => void} [opts.log]
+ * @returns {(vatPowers: unknown) => Promise<unknown>}
+ */
+export const makeCoreProposalBehavior = ({
+  manifestInstallRef,
+  getManifestCall,
+  E,
+  log = console.info,
+}) => {
+  const { entries, fromEntries } = Object;
+
+  // deeplyFulfilled is a bit overkill for what we need.
+  const shallowlyFulfilled = async obj => {
+    if (!obj) {
+      return obj;
+    }
+    const ents = await Promise.all(
+      entries(obj).map(async ([key, valueP]) => {
+        const value = await valueP;
+        return [key, value];
+      }),
+    );
+    return fromEntries(ents);
+  };
+
+  const behavior = async allPowers => {
+    const {
+      consume: { board },
+      evaluateInstallation,
+      installation: { produce: produceInstallations },
+      modules: {
+        utils: { runModuleBehaviors },
+      },
+    } = allPowers;
+    const [exportedGetManifest, ...manifestArgs] = getManifestCall;
+
+    // Get the on-chain installation containing the manifest and behaviors.
+    const manifestInstallation = await E(board).getValue(manifestInstallRef);
+    const behaviors = await evaluateInstallation(manifestInstallation);
+
+    const restoreRef = x => E(board).getValue(x);
+    const {
+      manifest,
+      options: rawOptions,
+      installations: rawInstallations,
+    } = await behaviors[exportedGetManifest](
+      harden({ restoreRef }),
+      ...manifestArgs,
+    );
+
+    // Await references in the options or installations.
+    const [options, installations] = await Promise.all(
+      [rawOptions, rawInstallations].map(shallowlyFulfilled),
+    );
+
+    // Publish the installations for behavior dependencies.
+    entries(installations || {}).forEach(([key, value]) => {
+      produceInstallations[key].resolve(value);
+    });
+
+    // Evaluate the manifest for our behaviors.
+    return runModuleBehaviors({
+      allPowers,
+      behaviors,
+      manifest,
+      makeConfig: (name, _permit) => {
+        log('coreProposal:', name);
+        return { options };
+      },
+    });
+  };
+
+  // Make the behavior the completion value.
+  return behavior;
+};

packages/deploy-script-support/src/createBundles.js

@@ -0,0 +1,79 @@
+import path from 'path';
+import { spawnSync } from 'child_process';
+import { createRequire } from 'module';
+
+const BUNDLE_SOURCE_PROGRAM = 'bundle-source';
+const require = createRequire(import.meta.url);
+
+export const createBundlesFromAbsolute = async sourceBundles => {
+  const prog = require.resolve(`.bin/${BUNDLE_SOURCE_PROGRAM}`);
+
+  const cacheToArgs = new Map();
+  for (const [srcPath, bundlePath] of sourceBundles) {
+    const cache = path.dirname(bundlePath);
+    const base = path.basename(bundlePath);
+
+    const match = base.match(/^bundle-(.*)\.js$/);
+    assert(match, `${bundlePath} is not 'DIR/bundle-NAME.js'`);
+    const bundle = match[1];
+
+    const args = cacheToArgs.get(cache) || ['--to', cache];
+    args.push(srcPath, bundle);
+    cacheToArgs.set(cache, args);
+  }
+
+  for (const args of cacheToArgs.values()) {
+    console.log(BUNDLE_SOURCE_PROGRAM, ...args);
+    const { status } = spawnSync(prog, args, { stdio: 'inherit' });
+    assert.equal(
+      status,
+      0,
+      `${BUNDLE_SOURCE_PROGRAM} failed with status ${status}`,
+    );
+  }
+};
+
+export const createBundles = async (sourceBundles, dirname = '.') => {
+  const absBundleSources = sourceBundles.map(([srcPath, bundlePath]) => [
+    require.resolve(srcPath, { paths: [dirname] }),
+    path.resolve(dirname, bundlePath),
+  ]);
+  return createBundlesFromAbsolute(absBundleSources);
+};
+
+export const extractProposalBundles = async (
+  dirProposalBuilder,
+  dirname = '.',
+) => {
+  const toBundle = new Map();
+
+  await Promise.all(
+    dirProposalBuilder.map(async ([dir, proposalBuilder]) => {
+      const home = path.resolve(dirname, dir);
+      const publishRef = x => x;
+      const install = async (src, bundleName) => {
+        if (bundleName) {
+          const bundlePath = path.resolve(home, bundleName);
+          const srcPath = require.resolve(src, { paths: [home] });
+          if (toBundle.has(bundlePath)) {
+            const oldSrc = toBundle.get(bundlePath);
+            assert.equal(
+              oldSrc,
+              srcPath,
+              `${bundlePath} already installed as ${oldSrc}, also given ${srcPath}`,
+            );
+          }
+          toBundle.set(bundlePath, srcPath);
+        }
+      };
+      return proposalBuilder({ publishRef, install });
+    }),
+  );
+
+  return createBundlesFromAbsolute(
+    [...toBundle.entries()].map(([bundlePath, srcPath]) => [
+      srcPath,
+      bundlePath,
+    ]),
+  );
+};

packages/deploy-script-support/src/helpers.js

@@ -10,6 +10,9 @@ import { makeSaveIssuer } from './saveIssuer.js';
 import { makeGetBundlerMaker } from './getBundlerMaker.js';
 import { assertOfferResult } from './assertOfferResult.js';
 import { installInPieces } from './installInPieces.js';
+import { makeWriteCoreProposal } from './writeCoreProposal.js';
+
+export * from './createBundles.js';
 
 // These are also hard-coded in lib-wallet.js.
 // TODO: Add methods to the wallet to access these without hard-coding
@@ -56,6 +59,11 @@ export const makeHelpers = async (homePromise, endowments) => {
     { bundleSource, lookup },
   );
 
+  const writeCoreProposal = makeWriteCoreProposal(homePromise, endowments, {
+    installInPieces,
+    getBundlerMaker,
+  });
+
   return {
     install,
     startInstance,
@@ -66,5 +74,6 @@ export const makeHelpers = async (homePromise, endowments) => {
     saveIssuer,
     depositInvitation,
     assertOfferResult,
+    writeCoreProposal,
   };
 };

packages/deploy-script-support/src/writeCoreProposal.js

@@ -0,0 +1,124 @@
+import fs from 'fs';
+import { E } from '@endo/far';
+import { deeplyFulfilled, makeMarshal } from '@endo/marshal';
+import { decodeToJustin } from '@endo/marshal/src/marshal-justin.js';
+
+import { makeCoreProposalBehavior } from './coreProposalBehavior.js';
+import { createBundles } from './createBundles.js';
+
+const { serialize } = makeMarshal();
+const stringify = (x, pretty = undefined) =>
+  decodeToJustin(JSON.parse(serialize(harden(x)).body), pretty);
+
+export const makeWriteCoreProposal = (
+  homeP,
+  endowments,
+  { getBundlerMaker, installInPieces },
+) => {
+  const { board, zoe } = E.get(homeP);
+  const { bundleSource, pathResolve } = endowments;
+
+  let bundlerCache;
+  const getBundler = () => {
+    if (!bundlerCache) {
+      bundlerCache = E(getBundlerMaker()).makeBundler({
+        zoe,
+      });
+    }
+    return bundlerCache;
+  };
+
+  const mergeProposalPermit = async (proposal, additionalManifest) => {
+    const {
+      sourceSpec,
+      getManifestCall: [exportedGetManifest, ...manifestArgs],
+    } = proposal;
+
+    const manifestNs = await import(pathResolve(sourceSpec));
+
+    // We only care about the manifest, not any restoreRef calls.
+    const { manifest } = await manifestNs[exportedGetManifest](
+      { restoreRef: x => `restoreRef:${x}` },
+      ...manifestArgs,
+    );
+
+    // FIXME: later actually merge the manifest with additionalManifest for
+    // minimalistic permit.
+    console.log('TODO: would merge', { manifest, additionalManifest });
+    return true;
+  };
+
+  const writeCoreProposal = async (filePrefix, proposalBuilder) => {
+    // Install an entrypoint.
+    const install = async (entrypoint, bundlePath) => {
+      const bundler = getBundler();
+      let bundle;
+      if (bundlePath) {
+        const bundleCache = pathResolve(bundlePath);
+        await createBundles([[pathResolve(entrypoint), bundleCache]]);
+        const ns = await import(bundleCache);
+        bundle = ns.default;
+      } else {
+        bundle = await bundleSource(pathResolve(entrypoint));
+      }
+      return installInPieces(bundle, bundler);
+    };
+
+    // Await a reference then publish to the board.
+    const publishRef = async refP => {
+      const ref = await refP;
+      return E(board).getId(ref);
+    };
+
+    // Create the proposal structure.
+    const proposal = await deeplyFulfilled(
+      harden(proposalBuilder({ publishRef, install })),
+    );
+    const { sourceSpec, getManifestCall } = proposal;
+
+    // Extract the top-level permit.
+    const t = 'writeCoreProposal';
+    const proposalPermit = await mergeProposalPermit(proposal, {
+      $writeCoreProposal: {
+        consume: { board: t },
+        evaluateInstallation: t,
+        installation: { produce: t },
+        modules: { utils: { runModuleBehaviors: t } },
+      },
+    });
+
+    // Get an install
+    const manifestInstallRef = await publishRef(install(sourceSpec));
+
+    const code = `\
+// This is generated by writeCoreProposal; please edit!
+/* eslint-disable */
+
+const manifestInstallRef = ${stringify(manifestInstallRef)};
+const getManifestCall = harden(${stringify(getManifestCall, true)});
+
+// Make the behavior the completion value.
+(${makeCoreProposalBehavior})({ manifestInstallRef, getManifestCall, E });
+`;
+
+    // end-of-line whitespace disrupts YAML formatting
+    const trimmed = code.replace(/[\r\t ]+$/gm, '');
+
+    const proposalPermitJsonFile = `${filePrefix}-permit.json`;
+    console.log(`creating ${proposalPermitJsonFile}`);
+    fs.writeFileSync(proposalPermitJsonFile, JSON.stringify(proposalPermit));
+
+    const proposalJsFile = `${filePrefix}.js`;
+    console.log(`creating ${proposalJsFile}`);
+    fs.writeFileSync(proposalJsFile, trimmed);
+
+    console.log(`\
+You can now run a governance submission command like:
+  agd tx gov submit-proposal swingset-core-eval ${proposalPermitJsonFile} ${proposalJsFile} \\
+    --title="Enable <something>" --description="Evaluate ${proposalJsFile}" --deposit=1000000ubld \\
+    --gas=auto --gas-adjustment=1.2
+`);
+  };
+
+  return writeCoreProposal;
+};