@agoric/deploy-script-support 0.9.7-pismo-dev-0d5327f.0 → 0.10.1-dev-bf4b59f.0

package/CHANGELOG.md

@@ -3,6 +3,30 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.10.0](https://github.com/Agoric/agoric-sdk/compare/@agoric/deploy-script-support@0.9.4...@agoric/deploy-script-support@0.10.0) (2023-05-19)
+
+
+### Features
+
+* **core-proposals:** use bundle hash for label ([2eec093](https://github.com/Agoric/agoric-sdk/commit/2eec0939bd87bfcc48634ab75e2ba830cdb321e3))
+* **deploy-script-support:** Publish bundles to chain if possible ([e8209da](https://github.com/Agoric/agoric-sdk/commit/e8209daec69fc6fd60f5d865cf29271eb106a995))
+* **deploy-script-support:** reenable for `agoric run init-core.js` without `ag-solo` ([2b2bc96](https://github.com/Agoric/agoric-sdk/commit/2b2bc96780b00d9c964dba6e6c5de36acd4a83c6))
+
+
+### Bug Fixes
+
+* **deploy-script-support:** avoid pulling in notifiers ([#7522](https://github.com/Agoric/agoric-sdk/issues/7522)) ([c73675d](https://github.com/Agoric/agoric-sdk/commit/c73675dad025b6600f0eafe9f8e768086e50b626))
+* **deploy-script-support:** update permits for `vatAdminSvc` ([73fef25](https://github.com/Agoric/agoric-sdk/commit/73fef256ab9abda1bda7e0619e8eee08c19f8883))
+* avoid using top-level `require` ([57ca2db](https://github.com/Agoric/agoric-sdk/commit/57ca2dbfbadb373f97d43b2fb4e90302c9149976))
+* change manifestInstallRef to manifestBundleRef ([4b87694](https://github.com/Agoric/agoric-sdk/commit/4b8769494eec1ce6bb5beda295389e8b982a9f37))
+* remove unused overridded restoreRef, fix default version ([7f1cd48](https://github.com/Agoric/agoric-sdk/commit/7f1cd488e2aa7f89473b2187016f7f0dcbc989e8))
+* rename makeEnactCoreProposalsFromBundleName to ..BundleRef ([7403f06](https://github.com/Agoric/agoric-sdk/commit/7403f06f58f0f50ecd154ad076a0a82317f3018b))
+* replace unsafe then with E.when ([#6684](https://github.com/Agoric/agoric-sdk/issues/6684)) ([d7a749e](https://github.com/Agoric/agoric-sdk/commit/d7a749eec4ddec9ba39bbc65434f03ec113cae7c))
+* replace zoe.install with zoe.installBundleID ([8a91b1b](https://github.com/Agoric/agoric-sdk/commit/8a91b1b06bf1a62c08156e595cf46f5194f73337)), closes [#6826](https://github.com/Agoric/agoric-sdk/issues/6826)
+* **deploy-script-support:** Use versioned bundleSource ([41af48e](https://github.com/Agoric/agoric-sdk/commit/41af48e0d44e0615a53d5e3fe9f019895a58f96d))
+
+
+
 ### [0.9.6](https://github.com/Agoric/agoric-sdk/compare/@agoric/deploy-script-support@0.9.5...@agoric/deploy-script-support@0.9.6) (2023-02-17)
 
 **Note:** Version bump only for package @agoric/deploy-script-support

package/exported.js

@@ -1,4 +1,3 @@
 import '@endo/bundle-source/exported.js';
-import '@agoric/vats/exported.js';
 
 import './src/externalTypes.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/deploy-script-support",
-  "version": "0.9.7-pismo-dev-0d5327f.0+0d5327f",
+  "version": "0.10.1-dev-bf4b59f.0+bf4b59f",
   "description": "Helpers and other support for writing deploy scripts",
   "type": "module",
   "main": "src/helpers.js",
@@ -13,7 +13,7 @@
     "test:xs": "exit 0",
     "lint-fix": "yarn lint:eslint --fix",
     "lint:eslint": "eslint .",
-    "lint:types": "tsc --maxNodeModuleJsDepth 5 -p jsconfig.json",
+    "lint:types": "tsc -p jsconfig.json",
     "lint": "run-s --continue-on-error lint:*"
   },
   "repository": {
@@ -34,25 +34,26 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/assert": "0.5.2-pismo-dev-0d5327f.0+0d5327f",
-    "@agoric/ertp": "0.15.6-pismo-dev-0d5327f.0+0d5327f",
-    "@agoric/import-manager": "0.3.9-pismo-dev-0d5327f.0+0d5327f",
-    "@agoric/nat": "^4.1.0",
-    "@agoric/notifier": "0.5.2-pismo-dev-0d5327f.0+0d5327f",
-    "@agoric/store": "0.8.6-pismo-dev-0d5327f.0+0d5327f",
-    "@agoric/vats": "0.13.3-pismo-dev-0d5327f.0+0d5327f",
-    "@agoric/zoe": "0.25.6-pismo-dev-0d5327f.0+0d5327f",
-    "@endo/base64": "^0.2.27",
-    "@endo/bundle-source": "^2.3.1",
-    "@endo/far": "^0.2.11",
-    "@endo/marshal": "^0.7.5",
-    "@endo/promise-kit": "^0.2.49",
-    "@endo/zip": "^0.2.27"
+    "@agoric/assert": "0.6.1-dev-bf4b59f.0+bf4b59f",
+    "@agoric/ertp": "0.16.1-dev-bf4b59f.0+bf4b59f",
+    "@agoric/import-manager": "0.3.10-dev-bf4b59f.0+bf4b59f",
+    "@agoric/internal": "0.3.1-dev-bf4b59f.0+bf4b59f",
+    "@agoric/notifier": "0.6.1-dev-bf4b59f.0+bf4b59f",
+    "@agoric/store": "0.9.1-dev-bf4b59f.0+bf4b59f",
+    "@agoric/zoe": "0.26.1-dev-bf4b59f.0+bf4b59f",
+    "@endo/base64": "^0.2.31",
+    "@endo/bundle-source": "^2.5.1",
+    "@endo/far": "^0.2.18",
+    "@endo/marshal": "^0.8.5",
+    "@endo/nat": "^4.1.27",
+    "@endo/promise-kit": "^0.2.56",
+    "@endo/zip": "^0.2.31"
   },
   "devDependencies": {
-    "@agoric/swingset-vat": "0.31.1-pismo-dev-0d5327f.0+0d5327f",
-    "ava": "^4.3.1",
-    "import-meta-resolve": "^1.1.1"
+    "@agoric/vats": "0.14.1-dev-bf4b59f.0+bf4b59f",
+    "@endo/init": "^0.5.56",
+    "ava": "^5.2.0",
+    "import-meta-resolve": "^2.2.1"
   },
   "files": [
     "src",
@@ -67,5 +68,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "0d5327f87310cf523834853b0546d0e217f37009"
+  "gitHead": "bf4b59f2128aca73d786429c6ef4a7c9cdfb6700"
 }

package/src/assertOfferResult.js

@@ -1,12 +1,14 @@
 // @ts-check
-import { assert, details as X } from '@agoric/assert';
+import { Fail } from '@agoric/assert';
 import { E } from '@endo/far';
 
-/** @type {AssertOfferResult} */
+/**
+ * @param {ERef<UserSeat>} seat
+ * @param {string} expectedOfferResult
+ * @returns {Promise<void>}
+ */
 export const assertOfferResult = async (seat, expectedOfferResult) => {
   const actualOfferResult = await E(seat).getOfferResult();
   actualOfferResult === expectedOfferResult ||
-    assert.fail(
-      X`offerResult (${actualOfferResult}) did not equal expected: ${expectedOfferResult}`,
-    );
+    Fail`offerResult (${actualOfferResult}) did not equal expected: ${expectedOfferResult}`;
 };

package/src/cachedBundleSpec.js

@@ -0,0 +1,32 @@
+const { Fail } = assert;
+
+/**
+ * @param {string} cacheDir
+ * @param {{ now: typeof Date.now, fs: import('fs').promises, pathResolve: typeof import('path').resolve }} param1
+ */
+export const makeCacheAndGetBundleSpec =
+  (cacheDir, { now, fs, pathResolve }) =>
+  async bundleP => {
+    const bundle = await bundleP;
+    const { endoZipBase64Sha512: hash } = bundle;
+
+    typeof hash === 'string' || Fail`bundle hash ${hash} must be a string`;
+    const bundleID = `b1-${hash}`;
+    const cacheFile = pathResolve(cacheDir, `${bundleID}.json`);
+
+    await fs.mkdir(cacheDir, { recursive: true });
+    try {
+      await fs.stat(cacheFile);
+    } catch (e) {
+      if (e.code !== 'ENOENT') {
+        throw e;
+      }
+      // FIXME: We could take a hard dependency on `tmp` here, but is it worth it?
+      const tmpFile = `${cacheFile}.${now()}`;
+      await fs.writeFile(tmpFile, JSON.stringify(bundle, null, 2), {
+        flag: 'wx',
+      });
+      await fs.rename(tmpFile, cacheFile);
+    }
+    return harden({ bundleID, fileName: cacheFile });
+  };

package/src/code-gen.js

@@ -1,8 +1,5 @@
 // @ts-check
-import { makeMarshal } from '@endo/marshal';
-import { decodeToJustin } from '@endo/marshal/src/marshal-justin.js';
-
-export { deeplyFulfilled } from '@endo/marshal';
+import { makeMarshal, decodeToJustin } from '@endo/marshal';
 
 const { keys, values, fromEntries } = Object;
 

package/src/coreProposalBehavior.js

@@ -1,8 +1,17 @@
+// @ts-check
 const t = 'makeCoreProposalBehavior';
 
+/**
+ * TODO import these from @agoric/vats when the types are better managed
+ *
+ * @typedef {*} ChainBootstrapSpace
+ * @typedef {*} BootstrapPowers
+ */
+
+// These permits apply to `allPowers` in `behavior` below.
 export const permits = {
-  consume: { board: t, agoricNamesAdmin: t },
-  evaluateInstallation: t,
+  consume: { agoricNamesAdmin: t, vatAdminSvc: t, zoe: t },
+  evaluateBundleCap: t,
   installation: { produce: t },
   modules: { utils: { runModuleBehaviors: t } },
 };
@@ -15,7 +24,7 @@ export const permits = {
  * definitions.
  *
  * @param {object} opts
- * @param {string} opts.manifestInstallRef
+ * @param {{ bundleName: string } | { bundleID: string }} opts.manifestBundleRef
  * @param {[string, ...unknown[]]} opts.getManifestCall
  * @param {Record<string, Record<string, unknown>>} [opts.overrideManifest]
  * @param {typeof import('@endo/far').E} opts.E
@@ -24,7 +33,7 @@ export const permits = {
  * @returns {(vatPowers: unknown) => Promise<unknown>}
  */
 export const makeCoreProposalBehavior = ({
-  manifestInstallRef,
+  manifestBundleRef,
   getManifestCall,
   overrideManifest,
   E,
@@ -47,10 +56,13 @@ export const makeCoreProposalBehavior = ({
     return fromEntries(ents);
   };
 
+  /** @param {ChainBootstrapSpace & BootstrapPowers & { evaluateBundleCap: any }} allPowers */
   const behavior = async allPowers => {
+    // NOTE: If updating any of these names extracted from `allPowers`, you must
+    // change `permits` above to reflect their accessibility.
     const {
-      consume: { board, agoricNamesAdmin },
-      evaluateInstallation,
+      consume: { vatAdminSvc, zoe, agoricNamesAdmin },
+      evaluateBundleCap,
       installation: { produce: produceInstallations },
       modules: {
         utils: { runModuleBehaviors },
@@ -58,25 +70,44 @@ export const makeCoreProposalBehavior = ({
     } = allPowers;
     const [exportedGetManifest, ...manifestArgs] = getManifestCall;
 
-    const restoreRef = overrideRestoreRef || (x => E(board).getValue(x));
+    const defaultRestoreRef = async ref => {
+      // extract-proposal.js creates these records, and bundleName is
+      // the name under which the bundle was installed into
+      // config.bundles
+      const p = ref.bundleName
+        ? E(vatAdminSvc).getBundleIDByName(ref.bundleName)
+        : ref.bundleID;
+      const bundleID = await p;
+      const label = bundleID.slice(0, 8);
+      return E(zoe).installBundleID(bundleID, label);
+    };
+    const restoreRef = overrideRestoreRef || defaultRestoreRef;
 
     // Get the on-chain installation containing the manifest and behaviors.
-    console.info('restoreRef, evaluateInstallation', {
-      manifestInstallRef,
+    console.info('evaluateBundleCap', {
+      manifestBundleRef,
       exportedGetManifest,
+      vatAdminSvc,
     });
-    const manifestInstallation = await restoreRef(manifestInstallRef);
-    const behaviors = await evaluateInstallation(manifestInstallation);
+    let bcapP;
+    if ('bundleName' in manifestBundleRef) {
+      bcapP = E(vatAdminSvc).getNamedBundleCap(manifestBundleRef.bundleName);
+    } else {
+      bcapP = E(vatAdminSvc).getBundleCap(manifestBundleRef.bundleID);
+    }
+    const bundleCap = await bcapP;
+
+    const manifestNS = await evaluateBundleCap(bundleCap);
 
     console.error('execute', {
       exportedGetManifest,
-      behaviors: Object.keys(behaviors),
+      behaviors: Object.keys(manifestNS),
     });
     const {
       manifest,
       options: rawOptions,
       installations: rawInstallations,
-    } = await behaviors[exportedGetManifest](
+    } = await manifestNS[exportedGetManifest](
       harden({ restoreRef }),
       ...manifestArgs,
     );
@@ -98,7 +129,7 @@ export const makeCoreProposalBehavior = ({
     // Evaluate the manifest for our behaviors.
     return runModuleBehaviors({
       allPowers,
-      behaviors,
+      behaviors: manifestNS,
       manifest: overrideManifest || manifest,
       makeConfig: (name, _permit) => {
         log('coreProposal:', name);
@@ -111,30 +142,16 @@ export const makeCoreProposalBehavior = ({
   return behavior;
 };
 
-export const makeEnactCoreProposalsFromBundleCap =
+export const makeEnactCoreProposalsFromBundleRef =
   ({ makeCoreProposalArgs, E }) =>
   async allPowers => {
-    const {
-      vatPowers: { D },
-      devices: { vatAdmin },
-      consume: { zoe },
-    } = allPowers;
-    const restoreRef = async ref => {
-      const { bundleID } = ref;
-      const bundleCap = D(vatAdmin).getNamedBundleCap(bundleID);
-      const bundle = D(bundleCap).getBundle();
-      const install = await E(zoe).install(bundle);
-      return install;
-    };
-
     await Promise.all(
       makeCoreProposalArgs.map(async ({ ref, call, overrideManifest }) => {
         const subBehavior = makeCoreProposalBehavior({
-          manifestInstallRef: ref,
+          manifestBundleRef: ref,
           getManifestCall: call,
           overrideManifest,
           E,
-          restoreRef,
         });
         return subBehavior(allPowers);
       }),

package/src/depositInvitation.js

@@ -1,13 +1,14 @@
 // @ts-check
-
 import { E } from '@endo/far';
 
 /**
  * @param {ERef<Purse>} zoeInvitationPurse
- * @returns {DepositInvitation}
  */
 export const makeDepositInvitation = zoeInvitationPurse => {
-  /** @type {DepositInvitation} */
+  /**
+   * @param {ERef<Invitation>} invitationP
+   * @returns {Promise<InvitationDetails>}
+   */
   const depositInvitation = async invitationP => {
     const invitation = await invitationP;
     // Deposit returns the amount deposited

package/src/endo-pieces-contract.js

@@ -3,7 +3,7 @@ import { E, Far } from '@endo/far';
 import { encodeBase64, decodeBase64 } from '@endo/base64';
 import { ZipWriter } from '@endo/zip';
 
-const { details: X, quote: q } = assert;
+const { Fail, quote: q } = assert;
 
 export const start = () => {
   /** @type { Map<string, [string, Uint8Array]>} */
@@ -45,7 +45,9 @@ export const start = () => {
        */
       addByRef: (name, hash) => {
         const entry = hashToEntry.get(hash);
-        assert(entry, X`hash not found: ${q(hash)}`);
+        if (!entry) {
+          throw Fail`hash not found: ${q(hash)}`;
+        }
         const [_n, content] = entry;
         nameToContent.set(name, [hash, content]);
       },

package/src/externalTypes.js

@@ -1,66 +1,46 @@
-/**
- * @callback InstallSaveAndPublish
- * @param {string} resolvedPath
- * @param {Petname} contractPetname
- * @returns {{ installation: Installation, id: string}}
- */
-
-/**
- * @typedef {object} StartInstanceResultWithDetailsNoInvitation
- * @property {any} creatorFacet
- * @property {any} publicFacet
- * @property {Instance} instance
- * @property {InvitationDetails} creatorInvitationDetails
- * @property {AdminFacet} adminFacet
- */
-
-/**
- * @typedef {object} OfferHelperConfig
- * @property {ERef<Invitation>=} invitation
- * @property {Partial<InvitationDetails>=} partialInvitationDetails
- * @property {Proposal} proposal
- * @property {Record<Keyword, Petname>} paymentsWithPursePetnames
- * @property {Record<Keyword, Petname>} payoutPursePetnames
- */
+// @ts-check
+export {};
 
+// TODO move this type somewhere better
 /**
- * @callback OfferHelper
- * @param {OfferHelperConfig} config
- * @returns {{seat: Promise<UserSeat>, deposited:
- * Promise<Array<Promise<Amount>>>, invitationDetails:
- * InvitationDetails}}
+ * @typedef {string | string[]} Petname A petname can either be a plain string
+ * or a path for which the first element is a petname for the origin, and the
+ * rest of the elements are a snapshot of the names that were first given by that
+ * origin.  We are migrating away from using plain strings, for consistency.
  */
 
 /**
- * @callback FindInvitationAmount
- * @param {Record<string, any>} invitationDetailsCriteria
- * @returns {Amount} invitationAmount
+ * @typedef ProposalResult
+ * @property {string} sourceSpec
+ * @property {[exportedGetManifest: string, ...manifestArgs: any[]]} getManifestCall
  */
 
 /**
- * @callback DepositInvitation
- * @param {ERef<Invitation>} invitationP
- * @returns {InvitationDetails}
+ * @typedef BundleHandle
+ * @property {string} [bundleName]
  */
 
 /**
- * @callback SaveIssuerHelper
- * @param {ERef<Issuer>} issuer
- * @param {Petname} brandPetname
- * @param {Petname} pursePetname
- * @returns {Promise<Petname>}
+ * @callback PublishBundleRef
+ * @param {ERef<BundleHandle>} bundle
+ * @returns {Promise<BundleHandle>}
  */
 
 /**
- * @callback AssertOfferResult
- * @param {ERef<UserSeat>} seat
- * @param {string} expectedOfferResult
- * @returns {Promise<void>}
+ * @callback InstallBundle
+ * @param {string} srcSpec
+ * @param {string} bundlePath
+ * @param {any} [opts]
+ * @returns {BundleHandle}
  */
 
 /**
- * @typedef {string | string[]} Petname A petname can either be a plain string
- * or a path for which the first element is a petname for the origin, and the
- * rest of the elements are a snapshot of the names that were first given by that
- * origin.  We are migrating away from using plain strings, for consistency.
+ * @callback ProposalBuilder
+ * @param {{
+ *   publishRef: PublishBundleRef,
+ *   install: InstallBundle,
+ *   wrapInstall?: <T>(f: T) => T }
+ * } powers
+ * @param {...any} args
+ * @returns {Promise<ProposalResult>}
  */

package/src/extract-proposal.js

@@ -1,17 +1,22 @@
 // @ts-check
+import { deeplyFulfilledObject } from '@agoric/internal';
 import fs from 'fs';
 import { createRequire } from 'module';
 import path from 'path';
 
-import { deeplyFulfilled, defangAndTrim, stringify } from './code-gen.js';
+import { defangAndTrim, stringify } from './code-gen.js';
 import {
   makeCoreProposalBehavior,
-  makeEnactCoreProposalsFromBundleCap,
+  makeEnactCoreProposalsFromBundleRef,
 } from './coreProposalBehavior.js';
 
-const { details: X } = assert;
+/**
+ * @typedef {string | { module: string, entrypoint: string, args?: Array<unknown> }} ConfigProposal
+ */
+
+const { details: X, Fail } = assert;
 
-const require = createRequire(import.meta.url);
+const req = createRequire(import.meta.url);
 
 /**
  * @param {(ModuleSpecifier | FilePath)[]} paths
@@ -22,7 +27,7 @@ const pathResolve = (...paths) => {
   const fileName = paths.pop();
   assert(fileName, '>=1 paths required');
   try {
-    return require.resolve(fileName, {
+    return req.resolve(fileName, {
       paths,
     });
   } catch (e) {
@@ -41,16 +46,16 @@ const pathResolve = (...paths) => {
  * but for sim-chain and such, they can be declared statically in
  * the chain configuration, in which case they are run at bootstrap.
  *
- * @param {(ModuleSpecifier | FilePath)[]} coreProposals - governance
+ * @param {ConfigProposal[]} coreProposals - governance
  * proposals to run at chain bootstrap for scenarios such as sim-chain.
  * @param {FilePath} [dirname]
- * @param {typeof makeEnactCoreProposalsFromBundleCap} [makeEnactCoreProposals]
+ * @param {typeof makeEnactCoreProposalsFromBundleRef} [makeEnactCoreProposals]
  * @param {(i: number) => number} [getSequenceForProposal]
  */
 export const extractCoreProposalBundles = async (
   coreProposals,
   dirname = '.',
-  makeEnactCoreProposals = makeEnactCoreProposalsFromBundleCap,
+  makeEnactCoreProposals = makeEnactCoreProposalsFromBundleRef,
   getSequenceForProposal,
 ) => {
   if (!getSequenceForProposal) {
@@ -63,7 +68,7 @@ export const extractCoreProposalBundles = async (
     .stat(dirname)
     .then(stbuf => (stbuf.isDirectory() ? dirname : path.dirname(dirname)));
 
-  /** @type {Map<{ bundleID?: string }, { source: string, bundle?: string }>} */
+  /** @type {Map<{ bundleName?: string }, { source: string, bundle?: string }>} */
   const bundleHandleToAbsolutePaths = new Map();
 
   const bundleToSource = new Map();
@@ -85,23 +90,18 @@ export const extractCoreProposalBundles = async (
         ({ module, entrypoint, args = [] } = coreProposal);
       }
 
-      assert.typeof(
-        module,
-        'string',
-        X`coreProposal module ${module} must be string`,
-      );
-      assert.typeof(
-        entrypoint,
-        'string',
-        X`coreProposal entrypoint ${entrypoint} must be string`,
-      );
-      assert(Array.isArray(args), X`coreProposal args ${args} must be array`);
+      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 = pathResolve(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 = pathResolve(initDir, srcSpec);
@@ -121,16 +121,17 @@ export const extractCoreProposalBundles = async (
             bundleToSource.set(absoluteBundle, absoluteSrc);
           }
         }
-        // Don't harden the bundleHandle since we need to set the bundleID on
+        // 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;
         bundleHandleToAbsolutePaths.has(handle) ||
-          assert.fail(X`${handle} not in installed bundles`);
+          Fail`${handle} not in installed bundles`;
         return handle;
       };
       const proposal = await ns[entrypoint]({ publishRef, install }, ...args);
@@ -148,21 +149,21 @@ export const extractCoreProposalBundles = async (
           return 0;
         })
         .map(([handle, absolutePaths], j) => {
-          // Transform the bundle handle identity into a bundleID reference.
-          handle.bundleID = `coreProposal${thisProposalSequence}_${j}`;
+          // Transform the bundle handle identity into a bundleName reference.
+          handle.bundleName = `coreProposal${thisProposalSequence}_${j}`;
           harden(handle);
 
           /** @type {[string, { sourceSpec: string }]} */
           const specEntry = [
-            handle.bundleID,
+            handle.bundleName,
             { sourceSpec: absolutePaths.source },
           ];
           return specEntry;
         });
 
-      // Now that we've assigned all the bundleIDs and hardened the handles, we
-      // can extract the behavior bundle.
-      const { sourceSpec, getManifestCall } = await deeplyFulfilled(
+      // 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),
       );
 
@@ -174,7 +175,7 @@ export const extractCoreProposalBundles = async (
       ](harden({ restoreRef: () => null }), ...manifestArgs);
 
       const behaviorBundleHandle = harden({
-        bundleID: `coreProposal${thisProposalSequence}_behaviors`,
+        bundleName: `coreProposal${thisProposalSequence}_behaviors`,
       });
       const behaviorAbsolutePaths = harden({
         source: behaviorSource,
@@ -185,7 +186,7 @@ export const extractCoreProposalBundles = async (
       );
 
       bundleSpecEntries.unshift([
-        behaviorBundleHandle.bundleID,
+        behaviorBundleHandle.bundleName,
         { sourceSpec: behaviorAbsolutePaths.source },
       ]);
 

package/src/getBundlerMaker.js

@@ -14,11 +14,12 @@ import { E } from '@endo/far';
 import url from 'url';
 
 export const makeGetBundlerMaker =
-  ({ board: optionalBoard, zoe, scratch }, { lookup, bundleSource }) =>
+  (homeP, { lookup, bundleSource }) =>
   async ({
     BUNDLER_MAKER_LOOKUP = JSON.stringify(['scratch', 'bundlerMaker']),
     log = console.log,
   } = {}) => {
+    const { board: optionalBoard, zoe, scratch } = await homeP;
     const lookupOrCreate = async () => {
       // Locate the bundler maker if any already exists at the given path.
       let bundlerMaker = await lookup(JSON.parse(BUNDLER_MAKER_LOOKUP));

package/src/helpers.js

@@ -1,10 +1,15 @@
 // @ts-check
 import '@agoric/zoe/exported.js';
 import { E } from '@endo/far';
+import bundleSource from '@endo/bundle-source';
+
+import fs from 'fs/promises';
+import os from 'os';
 
 import { makeInstall } from './install.js';
 import { makeOfferAndFindInvitationAmount } from './offer.js';
 import { makeStartInstance } from './startInstance.js';
+import { makeCacheAndGetBundleSpec } from './cachedBundleSpec.js';
 import { makeDepositInvitation } from './depositInvitation.js';
 import { makeSaveIssuer } from './saveIssuer.js';
 import { makeGetBundlerMaker } from './getBundlerMaker.js';
@@ -12,68 +17,131 @@ import { assertOfferResult } from './assertOfferResult.js';
 import { installInPieces } from './installInPieces.js';
 import { makeWriteCoreProposal } from './writeCoreProposal.js';
 
-export * from './createBundles.js';
+export * from '@agoric/internal/src/node/createBundles.js';
 
 // These are also hard-coded in lib-wallet.js.
 // TODO: Add methods to the wallet to access these without hard-coding
 // on this end.
 const ZOE_INVITE_PURSE_PETNAME = 'Default Zoe invite purse';
 
-export const makeHelpers = async (homePromise, endowments) => {
-  const { zoe, wallet, scratch, board } = E.get(homePromise);
-
-  const { bundleSource, lookup } = endowments;
-
-  const walletAdmin = E(wallet).getAdminFacet();
-  const installationManager = E(walletAdmin).getInstallationManager();
-  const instanceManager = E(walletAdmin).getInstanceManager();
-  const issuerManager = E(walletAdmin).getIssuerManager();
-
-  // TODO: Rather than using one purse with a hard-coded petname, find
-  // a better solution.
-  const zoeInvitationPurse = E(walletAdmin).getPurse(ZOE_INVITE_PURSE_PETNAME);
-
-  // Create the methods
-
-  const install = makeInstall(bundleSource, zoe, installationManager, board);
-
-  const startInstance = makeStartInstance(
-    issuerManager,
-    instanceManager,
-    zoe,
-    zoeInvitationPurse,
-  );
-
-  const { offer, findInvitationAmount } = makeOfferAndFindInvitationAmount(
-    walletAdmin,
-    zoe,
-    zoeInvitationPurse,
+/**
+ * @template {Record<PropertyKey, any>} T
+ *
+ * Lazily populate the returned object's properties from the properties of a
+ * source object.  Each `sourceObject` property value is sampled at most once.
+ *
+ * @param {T} sourceObject
+ * @returns {T}
+ */
+const makeLazyObject = sourceObject => {
+  const lazyObject = new Proxy(
+    {},
+    {
+      get(t, key) {
+        if (!(key in t)) {
+          if (key in sourceObject) {
+            t[key] = sourceObject[key];
+          }
+        }
+        return t[key];
+      },
+    },
   );
+  return /** @type {T} */ (lazyObject);
+};
 
-  const saveIssuer = makeSaveIssuer(walletAdmin, issuerManager);
-
-  const depositInvitation = makeDepositInvitation(zoeInvitationPurse);
-
-  const getBundlerMaker = makeGetBundlerMaker(
-    { board, scratch, zoe },
-    { bundleSource, lookup },
-  );
+export const makeHelpers = async (homePromise, endowments) => {
+  // Endowments provided via `agoric run` or `agoric deploy`.
+  const {
+    now,
+    lookup,
+    publishBundle,
+    pathResolve,
+    cacheDir = pathResolve(os.homedir(), '.agoric/cache'),
+  } = endowments;
+
+  // Internal-to-this-function lazy dependencies.
+  const deps = makeLazyObject({
+    get cacheAndGetBundleSpec() {
+      return makeCacheAndGetBundleSpec(cacheDir, {
+        now,
+        fs,
+        pathResolve,
+      });
+    },
+    get home() {
+      return E.get(homePromise);
+    },
+    get installationManager() {
+      return E(deps.walletAdmin).getInstallationManager();
+    },
+    get instanceManager() {
+      return E(deps.walletAdmin).getInstanceManager();
+    },
+    get issuerManager() {
+      return E(deps.walletAdmin).getIssuerManager();
+    },
+    get offerAndFind() {
+      return makeOfferAndFindInvitationAmount(
+        deps.walletAdmin,
+        deps.home.zoe,
+        deps.zoeInvitationPurse,
+      );
+    },
+    get walletAdmin() {
+      return E(deps.home.wallet).getAdminFacet();
+    },
+    get zoeInvitationPurse() {
+      // TODO: Rather than using one purse with a hard-coded petname, find
+      // a better solution.
+      return E(deps.walletAdmin).getPurse(ZOE_INVITE_PURSE_PETNAME);
+    },
+  });
 
-  const writeCoreProposal = makeWriteCoreProposal(homePromise, endowments, {
+  // The memo returned to our callers.
+  const helpers = makeLazyObject({
+    assertOfferResult,
+    get depositInvitation() {
+      return makeDepositInvitation(deps.zoeInvitationPurse);
+    },
+    get findInvitationAmount() {
+      return deps.offerAndFind.findInvitationAmount;
+    },
+    get install() {
+      return makeInstall(
+        bundleSource,
+        deps.home.zoe,
+        deps.installationManager,
+        deps.home.board,
+        publishBundle,
+        pathResolve,
+      );
+    },
     installInPieces,
-    getBundlerMaker,
+    get offer() {
+      return deps.offerAndFind.offer;
+    },
+    get saveIssuer() {
+      return makeSaveIssuer(deps.walletAdmin, deps.issuerManager);
+    },
+    get startInstance() {
+      return makeStartInstance(
+        deps.issuerManager,
+        deps.instanceManager,
+        deps.home.zoe,
+        deps.zoeInvitationPurse,
+      );
+    },
+    get getBundlerMaker() {
+      return makeGetBundlerMaker(homePromise, { bundleSource, lookup });
+    },
+    get writeCoreProposal() {
+      return makeWriteCoreProposal(homePromise, endowments, {
+        getBundleSpec: deps.cacheAndGetBundleSpec,
+        getBundlerMaker: helpers.getBundlerMaker,
+      });
+    },
   });
 
-  return {
-    install,
-    startInstance,
-    offer,
-    findInvitationAmount,
-    installInPieces,
-    getBundlerMaker,
-    saveIssuer,
-    depositInvitation,
-    assertOfferResult,
-    writeCoreProposal,
-  };
+  return helpers;
 };

package/src/install.js

@@ -1,31 +1,72 @@
 // @ts-check
-
 import './externalTypes.js';
 
 import { E } from '@endo/far';
 
+/** @typedef {import('@agoric/deploy-script-support/src/externalTypes').Petname} Petname */
+
+/**
+ * @callback BundleSource
+ * @param {string} startFilename - the filepath to start the bundling from
+ * @param {ModuleFormat | BundleOptions} [moduleFormat]
+ * @param {object} [powers]
+ * @param {ReadFn} [powers.read]
+ * @param {CanonicalFn} [powers.canonical]
+ */
+
 // XXX board is Board but specifying that leads to type errors with imports which aren't worth fixing right now
 /**
  * @param {BundleSource} bundleSource
  * @param {ERef<ZoeService>} zoe
  * @param {ERef<import('./startInstance.js').InstallationManager>} installationManager
  * @param {ERef<any>} board
- * @returns {InstallSaveAndPublish}
+ * @param {(bundle: any) => any} [publishBundle]
+ * @param {(path: string) => string} [pathResolve]
  */
-export const makeInstall = (bundleSource, zoe, installationManager, board) => {
-  /** @type {InstallSaveAndPublish} */
-  const install = async (resolvedPath, contractPetname) => {
-    console.log(`- Installing Contract Name: ${contractPetname}`);
+export const makeInstall = (
+  bundleSource,
+  zoe,
+  installationManager,
+  board,
+  publishBundle,
+  pathResolve,
+) => {
+  /**
+   * @param {string} contractPath
+   * @param {Petname} contractPetname
+   * @returns {Promise<{ installation: Installation, id: string}>}
+   */
+  const install = async (contractPath, contractPetname) => {
+    const resolvedPath = pathResolve ? pathResolve(contractPath) : contractPath;
 
     const bundle = await bundleSource(resolvedPath);
-    const installation = await E(zoe).install(bundle);
-
+    console.log(`- Publishing Contract Name: ${contractPetname}`);
+    const hashedBundle = await (publishBundle ? publishBundle(bundle) : bundle);
+    console.log(`- Installing Contract Name: ${contractPetname}`);
+    const installation = await E(zoe).install(hashedBundle);
+    console.log(
+      `- Adding contract to installation manager: ${contractPetname}`,
+    );
     await E(installationManager).add(contractPetname, installation);
 
-    console.log(`- Installed Contract Name: ${contractPetname}`);
-
+    // Let's share this installation with other people, so that
+    // they can run our contract code by making a contract
+    // instance (see the api deploy script in this repo to see an
+    // example of how to use the installation to make a new contract
+    // instance.)
+    // To share the installation, we're going to put it in the
+    // board. The board is a shared, on-chain object that maps
+    // strings to objects.
     const id = await E(board).getId(installation);
-    return { installation, id };
+
+    console.log('- SUCCESS! contract code installed on Zoe');
+    console.log(`-- Contract Name: ${contractPetname}`);
+    console.log(`-- Installation Board Id: ${id}`);
+
+    return {
+      installation,
+      id,
+    };
   };
   return install;
 };

package/src/installInPieces.js

@@ -12,9 +12,12 @@ const computeSha512 = bytes => {
 
 export const installInPieces = async (
   bundle,
-  bundler,
+  bundlerOrGetter,
   { maxBytesInFlight = 800_000, log = console.log, persist = false } = {},
 ) => {
+  const bundler =
+    typeof bundlerOrGetter === 'function' ? bundlerOrGetter() : bundlerOrGetter;
+
   // It would be nice to detect evaluation errors early like this:
   //   await importBundle(bundle, { endowments });
   // but importBundle only works inside SwingSet; checking here

package/src/offer.js

@@ -1,22 +1,35 @@
 // @ts-check
-
 import { E } from '@endo/far';
 import { assert } from '@agoric/assert';
-import { AmountMath } from '@agoric/ertp';
+// Avoid pulling in too many dependencies like notifiers
+import { AmountMath } from '@agoric/ertp/src/amountMath.js';
+
+/** @typedef {import('@agoric/deploy-script-support/src/externalTypes').Petname} Petname */
+
+/**
+ * @typedef {object} OfferHelperConfig
+ * @property {ERef<Invitation>} [invitation]
+ * @property {Partial<InvitationDetails>} [partialInvitationDetails]
+ * @property {Proposal} proposal
+ * @property {Record<Keyword, Petname>} paymentsWithPursePetnames
+ * @property {Record<Keyword, Petname>} payoutPursePetnames
+ */
 
 /**
  * @param {ERef<any>} walletAdmin - an internal type of the
  * wallet, not defined here
  * @param {ERef<ZoeService>} zoe
  * @param {ERef<Purse>} zoeInvitationPurse
- * @returns {{ offer: OfferHelper, findInvitationAmount: FindInvitationAmount }}
  */
 export const makeOfferAndFindInvitationAmount = (
   walletAdmin,
   zoe,
   zoeInvitationPurse,
 ) => {
-  /** @type {FindInvitationAmount} */
+  /**
+   * @param {Record<string, any>} invitationDetailsCriteria
+   * @returns {Promise<Amount>} invitationAmount
+   */
   const findInvitationAmount = async invitationDetailsCriteria => {
     const invitationAmount = await E(zoeInvitationPurse).getCurrentAmount();
 
@@ -79,16 +92,18 @@ export const makeOfferAndFindInvitationAmount = (
       const allDepositedP = Promise.all(
         Object.entries(paymentsP).map(([keyword, paymentP]) => {
           const depositInPurse = makeDepositInPurse(keyword);
-          return paymentP.then(depositInPurse);
+          return E.when(paymentP, depositInPurse);
         }),
       );
       return allDepositedP;
     };
     const paymentsPP = E(seat).getPayouts();
-    return paymentsPP.then(handlePayments);
+    return E.when(paymentsPP, handlePayments);
   };
 
-  /** @type {OfferHelper} */
+  /**
+   * @param {OfferHelperConfig} config
+   */
   const offer = async config => {
     const {
       invitation,

package/src/saveIssuer.js

@@ -1,15 +1,20 @@
 // @ts-check
-
 import { E } from '@endo/far';
 
+/** @typedef {import('@agoric/deploy-script-support/src/externalTypes').Petname} Petname */
+
 /**
  * @param {ERef<any>} walletAdmin - an internal type of the
  * wallet, not defined here
  * @param {ERef<import('./startInstance').IssuerManager>} issuerManager
- * @returns {SaveIssuerHelper}
  */
 export const makeSaveIssuer = (walletAdmin, issuerManager) => {
-  /** @type {SaveIssuerHelper} */
+  /**
+   * @param {ERef<Issuer>} issuerP
+   * @param {Petname} brandPetname
+   * @param {Petname} pursePetname
+   * @returns {Promise<Petname>}
+   */
   const saveIssuer = async (issuerP, brandPetname, pursePetname) => {
     console.log(`-- Installing issuer for: ${brandPetname}`);
 

package/src/startInstance.js

@@ -1,8 +1,9 @@
 // @ts-check
-
 import { assert } from '@agoric/assert';
 import { E, passStyleOf } from '@endo/far';
 
+/** @typedef {import('@agoric/deploy-script-support/src/externalTypes').Petname} Petname */
+
 /**
  * @template T
  * @typedef {object} PetnameManager

package/src/writeCoreProposal.js

@@ -1,34 +1,29 @@
 // @ts-check
 import fs from 'fs';
 import { E } from '@endo/far';
+import { deeplyFulfilled } from '@endo/marshal';
 
-import {
-  deeplyFulfilled,
-  defangAndTrim,
-  mergePermits,
-  stringify,
-} from './code-gen.js';
+import { createBundles } from '@agoric/internal/src/node/createBundles.js';
+import { defangAndTrim, mergePermits, stringify } from './code-gen.js';
 import { makeCoreProposalBehavior, permits } from './coreProposalBehavior.js';
-import { createBundles } from './createBundles.js';
 
 export const makeWriteCoreProposal = (
   homeP,
   endowments,
   {
     getBundlerMaker,
-    installInPieces,
+    getBundleSpec,
     log = console.log,
     writeFile = fs.promises.writeFile,
   },
 ) => {
-  const { board, zoe } = E.get(homeP);
   const { bundleSource, pathResolve } = endowments;
 
   let bundlerCache;
   const getBundler = () => {
     if (!bundlerCache) {
       bundlerCache = E(getBundlerMaker()).makeBundler({
-        zoe,
+        zoe: E.get(homeP).zoe,
       });
     }
     return bundlerCache;
@@ -57,33 +52,37 @@ export const makeWriteCoreProposal = (
 
   let mutex = Promise.resolve();
   const writeCoreProposal = async (filePrefix, proposalBuilder) => {
+    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;
+    };
+
     // Install an entrypoint.
     const install = async (entrypoint, bundlePath, opts) => {
-      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));
-      }
+      const bundle = getBundle(entrypoint, bundlePath);
 
       // Serialise the installations.
-      mutex = mutex.then(() => {
-        console.log('installing', { filePrefix, entrypoint, bundlePath });
-
-        return installInPieces(bundle, bundler, opts);
+      mutex = E.when(mutex, () => {
+        // console.log('installing', { filePrefix, entrypoint, bundlePath });
+        return getBundleSpec(bundle, getBundler, opts);
       });
       return mutex;
     };
 
     // Await a reference then publish to the board.
+    const cmds = [];
     const publishRef = async refP => {
-      const ref = await refP;
-      console.log('published', { filePrefix, ref });
-      return E(board).getId(ref);
+      const { fileName, ...ref } = await refP;
+      if (fileName) {
+        cmds.push(`agd tx swingset install-bundle @${fileName}`);
+      }
+
+      return harden(ref);
     };
 
     // Create the proposal structure.
@@ -91,25 +90,26 @@ export const makeWriteCoreProposal = (
       harden(proposalBuilder({ publishRef, install })),
     );
     const { sourceSpec, getManifestCall } = proposal;
-    console.log('created', { filePrefix, sourceSpec, getManifestCall });
+    // console.log('created', { filePrefix, sourceSpec, getManifestCall });
 
     // Extract the top-level permit.
     const { permits: proposalPermit, manifest: overrideManifest } =
       await mergeProposalPermit(proposal, permits);
 
     // Get an install
-    const manifestInstallRef = await publishRef(install(sourceSpec));
-    console.log('writing', { filePrefix, manifestInstallRef, sourceSpec });
+    const manifestBundleRef = await publishRef(install(sourceSpec));
+
+    // console.log('writing', { filePrefix, manifestBundleRef, sourceSpec });
     const code = `\
 // This is generated by writeCoreProposal; please edit!
 /* eslint-disable */
 
-const manifestInstallRef = ${stringify(manifestInstallRef)};
+const manifestBundleRef = ${stringify(manifestBundleRef)};
 const getManifestCall = harden(${stringify(getManifestCall, true)});
 const overrideManifest = ${stringify(overrideManifest, true)};
 
 // Make the behavior the completion value.
-(${makeCoreProposalBehavior})({ manifestInstallRef, getManifestCall, overrideManifest, E });
+(${makeCoreProposalBehavior})({ manifestBundleRef, getManifestCall, overrideManifest, E });
 `;
 
     const trimmed = defangAndTrim(code);
@@ -130,6 +130,8 @@ 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
+Remember to install bundles before submitting the proposal:
+  ${cmds.join('\n  ')}
 `);
   };
 

package/src/createBundles.js

@@ -1,79 +0,0 @@
-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,
-    ]),
-  );
-};