@agoric/deploy-script-support 0.10.4-dev-99fc025.0 → 0.10.4-dev-2c609b8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/deploy-script-support",
-  "version": "0.10.4-dev-99fc025.0+99fc025",
+  "version": "0.10.4-dev-2c609b8.0+2c609b8",
   "description": "Helpers and other support for writing deploy scripts",
   "type": "module",
   "main": "src/helpers.js",
@@ -34,14 +34,14 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-99fc025.0+99fc025",
-    "@agoric/ertp": "0.16.3-dev-99fc025.0+99fc025",
-    "@agoric/import-manager": "0.3.12-dev-99fc025.0+99fc025",
-    "@agoric/internal": "0.3.3-dev-99fc025.0+99fc025",
-    "@agoric/notifier": "0.6.3-dev-99fc025.0+99fc025",
-    "@agoric/store": "0.9.3-dev-99fc025.0+99fc025",
-    "@agoric/time": "0.3.3-dev-99fc025.0+99fc025",
-    "@agoric/zoe": "0.26.3-dev-99fc025.0+99fc025",
+    "@agoric/assert": "0.6.1-dev-2c609b8.0+2c609b8",
+    "@agoric/ertp": "0.16.3-dev-2c609b8.0+2c609b8",
+    "@agoric/import-manager": "0.3.12-dev-2c609b8.0+2c609b8",
+    "@agoric/internal": "0.3.3-dev-2c609b8.0+2c609b8",
+    "@agoric/notifier": "0.6.3-dev-2c609b8.0+2c609b8",
+    "@agoric/store": "0.9.3-dev-2c609b8.0+2c609b8",
+    "@agoric/time": "0.3.3-dev-2c609b8.0+2c609b8",
+    "@agoric/zoe": "0.26.3-dev-2c609b8.0+2c609b8",
     "@endo/base64": "^1.0.1",
     "@endo/bundle-source": "^3.0.2",
     "@endo/far": "^1.0.2",
@@ -51,7 +51,7 @@
     "@endo/zip": "^1.0.1"
   },
   "devDependencies": {
-    "@agoric/vats": "0.15.2-dev-99fc025.0+99fc025",
+    "@agoric/vats": "0.15.2-dev-2c609b8.0+2c609b8",
     "@endo/init": "^1.0.2",
     "ava": "^5.3.0",
     "import-meta-resolve": "^2.2.1"
@@ -75,5 +75,5 @@
   "typeCoverage": {
     "atLeast": 80.06
   },
-  "gitHead": "99fc025340e007fa01de005fa6133491d2c75d6e"
+  "gitHead": "2c609b84ddd07536404dedf45b118b1625ce81a0"
 }

package/src/extract-proposal.js

@@ -11,13 +11,38 @@ import {
 } from './coreProposalBehavior.js';
 
 /**
- * @typedef {string | { module: string, entrypoint: string, args?: Array<unknown> }} ConfigProposal
+ * @typedef {string | {module: string, entrypoint?: string, args?: Array<unknown>}} ConfigProposal
+ */
+
+/**
+ * @typedef {ConfigProposal[] | {steps: ConfigProposal[][]}} CoreProposals
  */
 
 const { Fail } = assert;
 
 const req = createRequire(import.meta.url);
 
+/**
+ * @param  {...(CoreProposals | undefined | null)} args
+ * @returns {CoreProposals}
+ */
+export const mergeCoreProposals = (...args) => {
+  /** @type {ConfigProposal[][]} */
+  const steps = [];
+  for (const coreProposal of args) {
+    if (!coreProposal) {
+      continue;
+    }
+    if ('steps' in coreProposal) {
+      steps.push(...coreProposal.steps);
+    } else {
+      steps.push(coreProposal);
+    }
+  }
+  return harden({ steps });
+};
+harden(mergeCoreProposals);
+
 /**
  * @param {(ModuleSpecifier | FilePath)[]} paths
  * @typedef {string} ModuleSpecifier
@@ -43,12 +68,12 @@ const findModule = (initDir, srcSpec) =>
 /**
  * @param {{ bundleID?: string, bundleName?: string }} handle - mutated then hardened
  * @param {string} sourceSpec - the specifier of a module to load
- * @param {number} sequence - the sequence number of the proposal
+ * @param {string} key - the key of the proposal
  * @param {string} piece - the piece of the proposal
  * @returns {Promise<[string, any]>}
  */
-const namedHandleToBundleSpec = async (handle, sourceSpec, sequence, piece) => {
-  handle.bundleName = `coreProposal${sequence}_${piece}`;
+const namedHandleToBundleSpec = async (handle, sourceSpec, key, piece) => {
+  handle.bundleName = `coreProposal${String(key)}_${piece}`;
   harden(handle);
   return harden([handle.bundleName, { sourceSpec }]);
 };
@@ -64,12 +89,12 @@ const namedHandleToBundleSpec = async (handle, sourceSpec, sequence, piece) => {
  * but for sim-chain and such, they can be declared statically in
  * the chain configuration, in which case they are run at bootstrap.
  *
- * @param {ConfigProposal[]} coreProposals - governance
+ * @param {CoreProposals} coreProposals - governance
  * proposals to run at chain bootstrap for scenarios such as sim-chain.
  * @param {FilePath} [dirname]
  * @param {object} [opts]
  * @param {typeof makeEnactCoreProposalsFromBundleRef} [opts.makeEnactCoreProposals]
- * @param {(i: number) => number} [opts.getSequenceForProposal]
+ * @param {(key: PropertyKey) => PropertyKey} [opts.getSequenceForProposal]
  * @param {typeof namedHandleToBundleSpec} [opts.handleToBundleSpec]
  */
 export const extractCoreProposalBundles = async (
@@ -79,7 +104,7 @@ export const extractCoreProposalBundles = async (
 ) => {
   const {
     makeEnactCoreProposals = makeEnactCoreProposalsFromBundleRef,
-    getSequenceForProposal = i => i,
+    getSequenceForProposal = key => key,
     handleToBundleSpec = namedHandleToBundleSpec,
   } = opts || {};
 
@@ -91,159 +116,177 @@ export const extractCoreProposalBundles = async (
   /** @type {Map<{ bundleID?: string, bundleName?: string }, { source: string, bundle?: string }>} */
   const bundleHandleToAbsolutePaths = new Map();
 
+  const proposalSteps =
+    'steps' in coreProposals ? coreProposals.steps : [coreProposals];
   const bundleToSource = new Map();
-  const extracted = await Promise.all(
-    coreProposals.map(async (coreProposal, i) => {
-      // console.debug(`Parsing core proposal:`, coreProposal);
+  const extractedSteps = await Promise.all(
+    proposalSteps.map((proposalStep, i) =>
+      Promise.all(
+        proposalStep.map(async (coreProposal, j) => {
+          const key = `${i}.${j}`;
+          // console.debug(`Parsing core proposal:`, coreProposal);
 
-      /** @type {string} */
-      let entrypoint;
-      /** @type {unknown[]} */
-      let args;
-      /** @type {string} */
-      let module;
-      if (typeof coreProposal === 'string') {
-        module = coreProposal;
-        entrypoint = 'defaultProposalBuilder';
-        args = [];
-      } else {
-        ({ module, entrypoint, args = [] } = coreProposal);
-      }
-
-      typeof module === 'string' ||
-        Fail`coreProposal module ${module} must be string`;
-      typeof entrypoint === 'string' ||
-        Fail`coreProposal entrypoint ${entrypoint} must be string`;
-      Array.isArray(args) || Fail`coreProposal args ${args} must be array`;
-
-      const thisProposalBundleHandles = new Set();
-      assert(getSequenceForProposal);
-      const thisProposalSequence = getSequenceForProposal(i);
-      const initPath = findModule(dirname, module);
-      const initDir = path.dirname(initPath);
-      /** @type {Record<string, import('./externalTypes.js').ProposalBuilder>} */
-      const ns = await import(initPath);
-      const install = (srcSpec, bundlePath) => {
-        const absoluteSrc = findModule(initDir, srcSpec);
-        const bundleHandle = {};
-        const absolutePaths = { source: absoluteSrc };
-        if (bundlePath) {
-          const absoluteBundle = pathResolve(initDir, bundlePath);
-          absolutePaths.bundle = absoluteBundle;
-          const oldSource = bundleToSource.get(absoluteBundle);
-          if (oldSource) {
-            oldSource === absoluteSrc ||
-              Fail`${bundlePath} already installed from ${oldSource}, now ${absoluteSrc}`;
+          /** @type {string} */
+          let entrypoint;
+          /** @type {unknown[]} */
+          let args;
+          /** @type {string} */
+          let module;
+          if (typeof coreProposal === 'string') {
+            module = coreProposal;
+            entrypoint = 'defaultProposalBuilder';
+            args = [];
           } else {
-            bundleToSource.set(absoluteBundle, absoluteSrc);
+            ({
+              module,
+              entrypoint = 'defaultProposalBuilder',
+              args = [],
+            } = coreProposal);
           }
-        }
-        // Don't harden the bundleHandle since we need to set the bundleName on
-        // its unique identity later.
-        thisProposalBundleHandles.add(bundleHandle);
-        bundleHandleToAbsolutePaths.set(bundleHandle, harden(absolutePaths));
-        return bundleHandle;
-      };
-      /** @type {import('./externalTypes.js').PublishBundleRef} */
-      const publishRef = async handleP => {
-        const handle = await handleP;
-        // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error -- https://github.com/Agoric/agoric-sdk/issues/4620 */
-        // @ts-ignore xxx types
-        bundleHandleToAbsolutePaths.has(handle) ||
-          Fail`${handle} not in installed bundles`;
-        return handle;
-      };
-      const proposal = await ns[entrypoint](
-        {
-          publishRef,
-          // @ts-expect-error not statically verified to return a full obj
-          install,
-        },
-        ...args,
-      );
 
-      // Add the proposal bundle handles in sorted order.
-      const bundleSpecEntries = await Promise.all(
-        [...thisProposalBundleHandles.keys()]
-          .map(handle => [handle, bundleHandleToAbsolutePaths.get(handle)])
-          .sort(([_hnda, { source: a }], [_hndb, { source: b }]) => {
-            if (a < b) {
-              return -1;
-            }
-            if (a > b) {
-              return 1;
+          typeof module === 'string' ||
+            Fail`coreProposal module ${module} must be string`;
+          typeof entrypoint === 'string' ||
+            Fail`coreProposal entrypoint ${entrypoint} must be string`;
+          Array.isArray(args) || Fail`coreProposal args ${args} must be array`;
+
+          const thisProposalBundleHandles = new Set();
+          assert(getSequenceForProposal);
+          const thisProposalSequence = getSequenceForProposal(key);
+          const initPath = findModule(dirname, module);
+          const initDir = path.dirname(initPath);
+          /** @type {Record<string, import('./externalTypes.js').ProposalBuilder>} */
+          const ns = await import(initPath);
+          const install = (srcSpec, bundlePath) => {
+            const absoluteSrc = findModule(initDir, srcSpec);
+            const bundleHandle = {};
+            const absolutePaths = { source: absoluteSrc };
+            if (bundlePath) {
+              const absoluteBundle = pathResolve(initDir, bundlePath);
+              absolutePaths.bundle = absoluteBundle;
+              const oldSource = bundleToSource.get(absoluteBundle);
+              if (oldSource) {
+                oldSource === absoluteSrc ||
+                  Fail`${bundlePath} already installed from ${oldSource}, now ${absoluteSrc}`;
+              } else {
+                bundleToSource.set(absoluteBundle, absoluteSrc);
+              }
             }
-            return 0;
-          })
-          .map(async ([handle, absolutePaths], j) => {
-            // Transform the bundle handle identity into a bundleName reference.
-            const specEntry = await handleToBundleSpec(
-              handle,
-              absolutePaths.source,
-              thisProposalSequence,
-              String(j),
+            // Don't harden the bundleHandle since we need to set the bundleName on
+            // its unique identity later.
+            thisProposalBundleHandles.add(bundleHandle);
+            bundleHandleToAbsolutePaths.set(
+              bundleHandle,
+              harden(absolutePaths),
             );
-            harden(handle);
-            return specEntry;
-          }),
-      );
+            return bundleHandle;
+          };
+          /** @type {import('./externalTypes.js').PublishBundleRef} */
+          const publishRef = async handleP => {
+            const handle = await handleP;
+            // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error -- https://github.com/Agoric/agoric-sdk/issues/4620 */
+            // @ts-ignore xxx types
+            bundleHandleToAbsolutePaths.has(handle) ||
+              Fail`${handle} not in installed bundles`;
+            return handle;
+          };
+          const proposal = await ns[entrypoint](
+            {
+              publishRef,
+              // @ts-expect-error not statically verified to return a full obj
+              install,
+            },
+            ...args,
+          );
 
-      // Now that we've assigned all the bundleNames and hardened the
-      // handles, we can extract the behavior bundle.
-      const { sourceSpec, getManifestCall } = await deeplyFulfilledObject(
-        harden(proposal),
-      );
+          // Add the proposal bundle handles in sorted order.
+          const bundleSpecEntries = await Promise.all(
+            [...thisProposalBundleHandles.keys()]
+              .map(handle => [handle, bundleHandleToAbsolutePaths.get(handle)])
+              .sort(([_hnda, { source: a }], [_hndb, { source: b }]) => {
+                if (a < b) {
+                  return -1;
+                }
+                if (a > b) {
+                  return 1;
+                }
+                return 0;
+              })
+              .map(async ([handle, absolutePaths], k) => {
+                // Transform the bundle handle identity into a bundleName reference.
+                const specEntry = await handleToBundleSpec(
+                  handle,
+                  absolutePaths.source,
+                  thisProposalSequence,
+                  String(k),
+                );
+                harden(handle);
+                return specEntry;
+              }),
+          );
 
-      const proposalSource = pathResolve(initDir, sourceSpec);
-      const proposalNS = await import(proposalSource);
-      const [manifestGetterName, ...manifestGetterArgs] = getManifestCall;
-      manifestGetterName in proposalNS ||
-        Fail`proposal ${proposalSource} missing export ${manifestGetterName}`;
-      const { manifest: customManifest } = await proposalNS[manifestGetterName](
-        harden({ restoreRef: () => null }),
-        ...manifestGetterArgs,
-      );
+          // Now that we've assigned all the bundleNames and hardened the
+          // handles, we can extract the behavior bundle.
+          const { sourceSpec, getManifestCall } = await deeplyFulfilledObject(
+            harden(proposal),
+          );
 
-      const behaviorBundleHandle = {};
-      const specEntry = await handleToBundleSpec(
-        behaviorBundleHandle,
-        proposalSource,
-        thisProposalSequence,
-        'behaviors',
-      );
-      bundleSpecEntries.unshift(specEntry);
+          const proposalSource = pathResolve(initDir, sourceSpec);
+          const proposalNS = await import(proposalSource);
+          const [manifestGetterName, ...manifestGetterArgs] = getManifestCall;
+          manifestGetterName in proposalNS ||
+            Fail`proposal ${proposalSource} missing export ${manifestGetterName}`;
+          const { manifest: customManifest } = await proposalNS[
+            manifestGetterName
+          ](harden({ restoreRef: () => null }), ...manifestGetterArgs);
 
-      bundleHandleToAbsolutePaths.set(
-        behaviorBundleHandle,
-        harden({
-          source: proposalSource,
-        }),
-      );
+          const behaviorBundleHandle = {};
+          const specEntry = await handleToBundleSpec(
+            behaviorBundleHandle,
+            proposalSource,
+            thisProposalSequence,
+            'proposalNS',
+          );
+          bundleSpecEntries.unshift(specEntry);
+
+          bundleHandleToAbsolutePaths.set(
+            behaviorBundleHandle,
+            harden({
+              source: proposalSource,
+            }),
+          );
 
-      return harden({
-        ref: behaviorBundleHandle,
-        call: getManifestCall,
-        customManifest,
-        bundleSpecs: bundleSpecEntries,
-      });
-    }),
+          return /** @type {const} */ ([
+            key,
+            {
+              ref: behaviorBundleHandle,
+              call: getManifestCall,
+              customManifest,
+              bundleSpecs: bundleSpecEntries,
+            },
+          ]);
+        }),
+      ),
+    ),
   );
 
   // Extract all the bundle specs in already-sorted order.
   const bundles = Object.fromEntries(
-    extracted.flatMap(({ bundleSpecs }) => bundleSpecs),
+    extractedSteps.flatMap(step =>
+      step.flatMap(([_key, { bundleSpecs }]) => bundleSpecs),
+    ),
   );
   harden(bundles);
 
-  // Extract the manifest references and calls.
-  const metadataRecords = extracted.map(({ ref, call, customManifest }) => ({
-    ref,
-    call,
-    customManifest,
-  }));
-  harden(metadataRecords);
+  const codeSteps = extractedSteps.map(extractedStep => {
+    // Extract the manifest references and calls.
+    const metadataRecords = extractedStep.map(([_key, extractedSpec]) => {
+      const { ref, call, customManifest } = extractedSpec;
+      return { ref, call, customManifest };
+    });
+    harden(metadataRecords);
 
-  const code = `\
+    const code = `\
 // This is generated by @agoric/deploy-script-support/src/extract-proposal.js - DO NOT EDIT
 /* eslint-disable */
 
@@ -260,11 +303,13 @@ const enactCoreProposals = ((
 ) => makeEnactCoreProposals({ metadataRecords, E }))();
 enactCoreProposals;
 `;
+    return defangAndTrim(code);
+  });
 
   // console.debug('created bundles from proposals:', coreProposals, bundles);
-  return {
+  return harden({
     bundles,
-    code: defangAndTrim(code),
+    codeSteps,
     bundleHandleToAbsolutePaths,
-  };
+  });
 };