@agoric/vats 0.15.2-dev-cbcea8c.0.cbcea8c → 0.15.2-dev-04baeed.0.04baeed

package/src/proposals/invite-committee.js

@@ -0,0 +1,207 @@
+import { deeplyFulfilledObject } from '@agoric/internal';
+import { E } from '@endo/far';
+import { reserveThenDeposit } from './reserve-then-deposit.js';
+
+/**
+ * @import {Installation, Instance, Invitation} from '@agoric/zoe';
+ * @import {StartedInstanceKit} from '@agoric/zoe/src/zoeService/utils.js';
+ * @import {CommitteeElectorateCreatorFacet} from '@agoric/governance/src/committee.js';
+ * @import {start as CharterStart} from '@agoric/governance/src/econCommitteeCharter.js';
+ * @import {BootstrapPowers, Producer} from '../core/types.js';
+ */
+
+/**
+ * Relocated from `inter-protocol` (refs #12719). Invites the economic
+ * committee members and stands up the (generic) charter through which they pose
+ * governance questions. The only governed contract that remains is provisionPool
+ * (in this package), so addGovernorsToEconCharter registers it instead of the
+ * former Inter Protocol contracts.
+ *
+ * @typedef {StartedInstanceKit<typeof CharterStart>} EconCharterStartResult
+ */
+
+/**
+ * @typedef {BootstrapPowers & {
+ *   consume: {
+ *     economicCommitteeCreatorFacet: Promise<CommitteeElectorateCreatorFacet>;
+ *     econCharterKit: Promise<EconCharterStartResult>;
+ *   };
+ *   produce: { econCharterKit: Producer<EconCharterStartResult> };
+ * }} EconCommitteePowers
+ */
+
+const { values } = Object;
+
+/** @type {<X, Y>(xs: X[], ys: Y[]) => [X, Y][]} */
+const zip = (xs, ys) => xs.map((x, i) => [x, ys[i]]);
+
+const EC_HIGH_PRIORITY_SENDERS_NAMESPACE = 'economicCommittee';
+
+/**
+ * @param {EconCommitteePowers} powers
+ * @param {{ options: { voterAddresses: Record<string, string> } }} param1
+ */
+export const inviteCommitteeMembers = async (
+  {
+    consume: { namesByAddressAdmin, economicCommitteeCreatorFacet, ...consume },
+  },
+  { options: { voterAddresses } },
+) => {
+  const invitations = await E(
+    economicCommitteeCreatorFacet,
+  ).getVoterInvitations();
+  assert.equal(invitations.length, values(voterAddresses).length);
+
+  const highPrioritySendersManager = await consume.highPrioritySendersManager;
+
+  /** @param {[string, Promise<Invitation>][]} addrInvitations */
+  const distributeInvitations = async addrInvitations => {
+    await Promise.all(
+      addrInvitations.map(async ([addr, invitationP]) => {
+        const debugName = `econ committee member ${addr}`;
+        await reserveThenDeposit(debugName, namesByAddressAdmin, addr, [
+          invitationP,
+        ]).catch(err => console.error(`failed deposit to ${debugName}`, err));
+        if (highPrioritySendersManager) {
+          await E(highPrioritySendersManager).add(
+            EC_HIGH_PRIORITY_SENDERS_NAMESPACE,
+            addr,
+          );
+        }
+      }),
+    );
+  };
+
+  // This doesn't resolve until the committee members create their smart wallets.
+  // Don't block bootstrap on it.
+  void distributeInvitations(zip(values(voterAddresses), invitations));
+};
+
+harden(inviteCommitteeMembers);
+
+/** @param {EconCommitteePowers} powers */
+export const startEconCharter = async ({
+  consume: { zoe },
+  produce: { econCharterKit },
+  installation: {
+    consume: { binaryVoteCounter: counterP, econCommitteeCharter: installP },
+  },
+  instance: {
+    produce: { econCommitteeCharter: instanceP },
+  },
+}) => {
+  const [charterInstall0, counterInstall] = await Promise.all([
+    installP,
+    counterP,
+  ]);
+  // vats types the econCommitteeCharter installation generically (by name);
+  // narrow it to the governance charter contract.
+  const charterInstall = /** @type {Installation<typeof CharterStart>} */ (
+    charterInstall0
+  );
+  const terms = await deeplyFulfilledObject(
+    harden({
+      binaryVoteCounterInstallation: counterInstall,
+    }),
+  );
+
+  /** @type {Promise<EconCharterStartResult>} */
+  const startResult = E(zoe).startInstance(
+    charterInstall,
+    undefined,
+    terms,
+    undefined,
+    'econCommitteeCharter',
+  );
+  instanceP.resolve(E.get(startResult).instance);
+  econCharterKit.resolve(startResult);
+};
+harden(startEconCharter);
+
+/**
+ * Introduce the (only remaining) governed contract, provisionPool, to the
+ * charter so the committee can vote on its parameters.
+ *
+ * @param {EconCommitteePowers} powers
+ */
+export const addGovernorsToEconCharter = async ({
+  consume: { econCharterKit, provisionPoolStartResult },
+}) => {
+  const { creatorFacet } = E.get(econCharterKit);
+
+  const ppKit = await provisionPoolStartResult;
+  await E(creatorFacet).addInstance(
+    ppKit.instance,
+    ppKit.governorCreatorFacet,
+    'provisionPool',
+  );
+};
+
+harden(addGovernorsToEconCharter);
+
+/**
+ * @param {EconCommitteePowers} powers
+ * @param {{ options: { voterAddresses: Record<string, string> } }} param1
+ */
+export const inviteToEconCharter = async (
+  { consume: { namesByAddressAdmin, econCharterKit } },
+  { options: { voterAddresses } },
+) => {
+  const { creatorFacet } = E.get(econCharterKit);
+
+  // This doesn't resolve until the committee members create their smart wallets.
+  // Don't block bootstrap on it.
+  void Promise.all(
+    values(voterAddresses).map(async addr => {
+      const debugName = `econ charter member ${addr}`;
+      reserveThenDeposit(debugName, namesByAddressAdmin, addr, [
+        E(creatorFacet).makeCharterMemberInvitation(),
+      ]).catch(err => console.error(`failed deposit to ${debugName}`, err));
+    }),
+  );
+};
+
+harden(inviteToEconCharter);
+
+export const getManifestForInviteCommittee = async (
+  { restoreRef },
+  { voterAddresses, econCommitteeCharterRef },
+) => {
+  const t = true;
+  return {
+    manifest: {
+      [inviteCommitteeMembers.name]: {
+        consume: {
+          namesByAddressAdmin: t,
+          economicCommitteeCreatorFacet: t,
+          highPrioritySendersManager: t,
+        },
+      },
+      [startEconCharter.name]: {
+        consume: { zoe: t },
+        produce: { econCharterKit: t },
+        installation: {
+          consume: { binaryVoteCounter: t, econCommitteeCharter: t },
+        },
+        instance: {
+          produce: { econCommitteeCharter: t },
+        },
+      },
+      [addGovernorsToEconCharter.name]: {
+        consume: {
+          econCharterKit: t,
+          provisionPoolStartResult: t,
+        },
+      },
+      [inviteToEconCharter.name]: {
+        consume: { namesByAddressAdmin: t, econCharterKit: t },
+      },
+    },
+    installations: {
+      econCommitteeCharter: restoreRef(econCommitteeCharterRef),
+    },
+    options: {
+      voterAddresses,
+    },
+  };
+};

package/src/proposals/reserve-then-deposit.d.ts

@@ -0,0 +1,6 @@
+export function reserveThenGetNamePaths(nameAdmin: ERef<NameAdmin>, paths: string[][]): Promise<unknown[]>;
+export function reserveThenDeposit(debugName: string, namesByAddressAdmin: ERef<NameAdmin>, addr: string, payments: ERef<Payment>[]): Promise<void>;
+import type { NameAdmin } from '@agoric/vats';
+import type { ERef } from '@endo/far';
+import type { Payment } from '@agoric/ertp';
+//# sourceMappingURL=reserve-then-deposit.d.ts.map

package/src/proposals/reserve-then-deposit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reserve-then-deposit.d.ts","sourceRoot":"","sources":["reserve-then-deposit.js"],"names":[],"mappings":"AAmBO,mDAJI,KAAK,SAAS,CAAC,SACf,MAAM,EAAE,EAAE,GACR,OAAO,CAAC,OAAO,EAAE,CAAC,CAgC9B;AAWM,8CALI,MAAM,uBACN,KAAK,SAAS,CAAC,QACf,MAAM,YACN,KAAK,OAAO,CAAC,EAAE,iBAwBzB;+BA5E2B,cAAc;0BADnB,WAAW;6BAER,cAAc"}

package/src/proposals/reserve-then-deposit.js

@@ -0,0 +1,83 @@
+import { Fail } from '@endo/errors';
+import { E } from '@endo/far';
+import { WalletName } from '@agoric/internal';
+
+/**
+ * @import {ERef} from '@endo/far';
+ * @import {NameAdmin} from '@agoric/vats';
+ * @import {Payment} from '@agoric/ertp';
+ */
+
+/**
+ * Reserve and look up a list of name paths, waiting for each path segment to be
+ * reserved before resolving. Relocated from `inter-protocol` (refs
+ * #12719); used by the economicCommittee/charter bootstrap proposals.
+ *
+ * @param {ERef<NameAdmin>} nameAdmin
+ * @param {string[][]} paths
+ * @returns {Promise<unknown[]>}
+ */
+export const reserveThenGetNamePaths = async (nameAdmin, paths) => {
+  /**
+   * @param {ERef<NameAdmin>} nextAdmin
+   * @param {string[]} path
+   * @returns {Promise<unknown>}
+   */
+  const nextPath = async (nextAdmin, path) => {
+    const [nextName, ...rest] = path;
+    assert.typeof(nextName, 'string');
+
+    // Ensure we wait for the next name until it exists.
+    await E(nextAdmin).reserve(nextName);
+
+    if (rest.length === 0) {
+      // Now return the readonly lookup of the name.
+      const nameHub = E(nextAdmin).readonly();
+      return E(nameHub).lookup(nextName);
+    }
+
+    // Wait until the next admin is resolved.
+    const restAdmin = await E(nextAdmin).lookupAdmin(nextName);
+    return nextPath(restAdmin, rest);
+  };
+
+  return Promise.all(
+    paths.map(async path => {
+      Array.isArray(path) || Fail`path ${path} is not an array`;
+      return nextPath(nameAdmin, path);
+    }),
+  );
+};
+
+/**
+ * Deposit payments (e.g. invitations) to an address's deposit facet, reserving
+ * the name path first so it resolves once the recipient provisions a wallet.
+ *
+ * @param {string} debugName
+ * @param {ERef<NameAdmin>} namesByAddressAdmin
+ * @param {string} addr
+ * @param {ERef<Payment>[]} payments
+ */
+export const reserveThenDeposit = async (
+  debugName,
+  namesByAddressAdmin,
+  addr,
+  payments,
+) => {
+  console.info('awaiting depositFacet for', debugName);
+  /** @type {any} */
+  const [depositFacet] = await reserveThenGetNamePaths(namesByAddressAdmin, [
+    [addr, WalletName.depositFacet],
+  ]);
+  console.info('depositing to', debugName);
+  await Promise.allSettled(
+    payments.map(async (paymentP, i) => {
+      const payment = await paymentP;
+      await E(depositFacet).receive(payment);
+      console.info(
+        `confirmed deposit ${i + 1}/${payments.length} for`,
+        debugName,
+      );
+    }),
+  );
+};

package/src/proposals/restart-vats-proposal.d.ts

@@ -1,4 +1,4 @@
-export function restartVats({ consume }: BootstrapPowers & EconomyKitSpace, { options }: {
+export function restartVats({ consume }: BootstrapPowers, { options }: {
     options: {
         skip: string[];
     };
@@ -11,36 +11,17 @@ export function getManifestForRestart(_powers: any, options: any): {
                 governedContractKits: boolean;
                 instancePrivateArgs: boolean;
                 loadCriticalVat: boolean;
-                psmKit: boolean;
                 vatStore: boolean;
                 vatAdminSvc: boolean;
                 vatUpgradeInfo: boolean;
                 zoe: string;
                 provisioning: string;
-                vaultFactoryKit: boolean;
+                provisionPoolStartResult: boolean;
             };
             produce: {};
         };
     };
     options: any;
 };
-/**
- * The subset of EconomyBootstrapSpace (from
- * inter-protocol/src/proposals/econ-behaviors.js) that this proposal reads,
- * declared structurally so this package doesn't depend on inter-protocol.
- */
-export type EconomyKitSpace = PromiseSpaceOf<{
-    psmKit: MapStore<Brand, {
-        label: string;
-        psm: Instance<any>;
-        psmAdminFacet: AdminFacet;
-    }>;
-    vaultFactoryKit: unknown;
-}>;
 import type { BootstrapPowers } from '../core/types.js';
-import type { Brand } from '@agoric/ertp';
-import type { Instance } from '@agoric/zoe/src/zoeService/utils.js';
-import type { AdminFacet } from '@agoric/zoe';
-import type { MapStore } from '@agoric/store';
-import type { PromiseSpaceOf } from '../core/types.js';
 //# sourceMappingURL=restart-vats-proposal.d.ts.map

package/src/proposals/restart-vats-proposal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"restart-vats-proposal.d.ts","sourceRoot":"","sources":["restart-vats-proposal.js"],"names":[],"mappings":"AAuDO,yCAJI,eAAe,GAAG,eAAe,eAEzC;IAAmC,OAAO,EAAlC;QAAE,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE;CAC5B,iBAmHA;AAGM;;QAEH,CAAC,WAAW,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;UAejB;;;EAGH;;;;;;8BA7KW,eAAe;IACvB,MAAM,EAAE,SACZ,KAAW,EACX;QAAQ,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,SAAS,GAAG,CAAC,CAAC;QAAC,aAAa,EAAE,UAAU,CAAA;KAAE,CACjE,CAAC;IACF,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;qCAd6C,kBAAkB;2BAL5C,cAAc;8BAGX,qCAAqC;gCAD1B,aAAa;8BADxB,eAAe;oCAIQ,kBAAkB"}
+{"version":3,"file":"restart-vats-proposal.d.ts","sourceRoot":"","sources":["restart-vats-proposal.js"],"names":[],"mappings":"AAyCO,yCAJI,eAAe,eAEvB;IAAmC,OAAO,EAAlC;QAAE,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE;CAC5B,iBA4GA;AAGM;;QAEH,CAAC,WAAW,CAAC,IAAI,CAAC;;;;;;;;;;;;;;UAcjB;;;EAGH;qCA/JgD,kBAAkB"}

package/src/proposals/restart-vats-proposal.js

@@ -12,20 +12,6 @@ import { E, getInterfaceOf } from '@endo/far';
  * @import {BootstrapPowers, PromiseSpaceOf} from '../core/types.js';
  */
 
-/**
- * The subset of EconomyBootstrapSpace (from
- * inter-protocol/src/proposals/econ-behaviors.js) that this proposal reads,
- * declared structurally so this package doesn't depend on inter-protocol.
- *
- * @typedef {PromiseSpaceOf<{
- *   psmKit: MapStore<
- *     Brand,
- *     { label: string; psm: Instance<any>; psmAdminFacet: AdminFacet }
- *   >;
- *   vaultFactoryKit: unknown;
- * }>} EconomyKitSpace
- */
-
 const trace = makeTracer('RV');
 
 const HR = '----------------';
@@ -49,7 +35,7 @@ const vatUpgradeStatus = {
 };
 
 /**
- * @param {BootstrapPowers & EconomyKitSpace} space
+ * @param {BootstrapPowers} space
  * @param {object} config
  * @param {{ skip: string[] }} config.options
  */
@@ -59,16 +45,15 @@ export const restartVats = async ({ consume }, { options }) => {
   trace('restartVats start', options);
   mustMatch(options, harden({ skip: M.arrayOf(M.string()) }));
 
-  trace('awaiting VaultFactorKit as a proxy for "bootstrap done"');
-  await consume.vaultFactoryKit;
+  trace('awaiting provisionPoolStartResult as a proxy for "bootstrap done"');
+  await consume.provisionPoolStartResult;
 
   trace('testing restarts');
-  const { contractKits, governedContractKits, psmKit, vatStore } =
+  const { contractKits, governedContractKits, vatStore } =
     await deeplyFulfilledObject(
       harden({
         contractKits: consume.contractKits,
         governedContractKits: consume.governedContractKits,
-        psmKit: consume.psmKit,
         vatStore: consume.vatStore,
       }),
     );
@@ -136,12 +121,6 @@ export const restartVats = async ({ consume }, { options }) => {
     );
   }
 
-  trace('iterating over psmKit');
-  for (const kit of psmKit.values()) {
-    console.log('restarting PSM', kit.label);
-    await tryRestartContract(kit.label, kit.psm, kit.psmAdminFacet);
-  }
-
   trace('iterating over vatStore');
   for (const [name, { adminNode }] of vatStore.entries()) {
     const status = vatUpgradeStatus[name];
@@ -178,13 +157,12 @@ export const getManifestForRestart = (_powers, options) => ({
         governedContractKits: true,
         instancePrivateArgs: true,
         loadCriticalVat: true,
-        psmKit: true,
         vatStore: true,
         vatAdminSvc: true,
         vatUpgradeInfo: true,
         zoe: 'zoe',
         provisioning: 'provisioning',
-        vaultFactoryKit: true,
+        provisionPoolStartResult: true,
       },
       produce: {},
     },

package/src/proposals/start-econ-committee.d.ts

@@ -0,0 +1,91 @@
+export function startEconomicCommittee({ consume: { board, chainStorage, diagnostics, zoe }, produce: { economicCommitteeKit, economicCommitteeCreatorFacet }, installation: { consume: { committee }, }, instance: { produce: { economicCommittee }, }, }: BootstrapPowers & {
+    produce: {
+        economicCommitteeKit: Producer<StartedInstanceKit<typeof CommitteeStart> & {
+            label: string;
+        }>;
+        economicCommitteeCreatorFacet: Producer<CommitteeElectorateCreatorFacet>;
+    };
+    instance: {
+        produce: {
+            economicCommittee: Producer<Instance<typeof CommitteeStart>>;
+        };
+    };
+}, { options: { econCommitteeOptions } }: {
+    options?: {
+        econCommitteeOptions?: EconCommitteeOptions | undefined;
+    } | undefined;
+}): Promise<void>;
+export const ECON_COMMITTEE_MANIFEST: {
+    [startEconomicCommittee.name]: {
+        consume: {
+            board: true;
+            chainStorage: true;
+            diagnostics: true;
+            zoe: true;
+        };
+        produce: {
+            economicCommitteeKit: true;
+            economicCommitteeCreatorFacet: string;
+        };
+        installation: {
+            consume: {
+                committee: string;
+            };
+        };
+        instance: {
+            produce: {
+                economicCommittee: string;
+            };
+        };
+    };
+};
+export function getManifestForEconCommittee({ restoreRef }: {
+    restoreRef: any;
+}, { installKeys, econCommitteeOptions }: {
+    installKeys: any;
+    econCommitteeOptions: any;
+}): {
+    manifest: {
+        [startEconomicCommittee.name]: {
+            consume: {
+                board: true;
+                chainStorage: true;
+                diagnostics: true;
+                zoe: true;
+            };
+            produce: {
+                economicCommitteeKit: true;
+                economicCommitteeCreatorFacet: string;
+            };
+            installation: {
+                consume: {
+                    committee: string;
+                };
+            };
+            instance: {
+                produce: {
+                    economicCommittee: string;
+                };
+            };
+        };
+    };
+    installations: {
+        contractGovernor: any;
+        committee: any;
+        binaryVoteCounter: any;
+    };
+    options: {
+        econCommitteeOptions: any;
+    };
+};
+export type EconCommitteeOptions = {
+    committeeName?: string | undefined;
+    committeeSize?: number | undefined;
+};
+import type { BootstrapPowers } from '../core/types.js';
+import type { start as CommitteeStart } from '@agoric/governance/src/committee.js';
+import type { StartedInstanceKit } from '@agoric/zoe/src/zoeService/utils.js';
+import type { Producer } from '../core/types.js';
+import type { CommitteeElectorateCreatorFacet } from '@agoric/governance/src/committee.js';
+import type { Instance } from '@agoric/zoe';
+//# sourceMappingURL=start-econ-committee.d.ts.map

package/src/proposals/start-econ-committee.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-econ-committee.d.ts","sourceRoot":"","sources":["start-econ-committee.js"],"names":[],"mappings":"AAkDO,4PAfI,eAAe,GAAG;IACxB,OAAO,EAAE;QACP,oBAAoB,EAAE,SAC5B,mBAA2B,qBAAqB,CAAC,GAAG;YAAE,KAAK,EAAE,MAAM,CAAA;SAAE,CAC9D,CAAC;QACF,6BAA6B,EAAE,SAAS,+BAA+B,CAAC,CAAC;KAC1E,CAAC;IACF,QAAQ,EAAE;QACR,OAAO,EAAE;YAAE,iBAAiB,EAAE,SAAS,SAAS,qBAAqB,CAAC,CAAC,CAAA;SAAE,CAAC;KAC3E,CAAC;CACH,yCAED;IAAwB,OAAO;;;CACoC,iBAyDrE;AAGD;IACE,CAAC,sBAAsB,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;MAiB5B;EACA;AAKI;;;;;;;QAvBL,CAAC,sBAAsB,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;UAiB5B;;;;;;;;;;EAqBF;;;;;qCAxI2C,kBAAkB;6CADa,qCAAqC;wCAD3E,qCAAqC;8BAE9B,kBAAkB;qDADa,qCAAqC;8BAFrF,aAAa"}

package/src/proposals/start-econ-committee.js

@@ -0,0 +1,148 @@
+import { makeTracer } from '@agoric/internal';
+import {
+  assertPathSegment,
+  makeStorageNodeChild,
+} from '@agoric/internal/src/lib-chainStorage.js';
+import { E } from '@endo/far';
+
+/**
+ * @import {Instance} from '@agoric/zoe';
+ * @import {StartedInstanceKit} from '@agoric/zoe/src/zoeService/utils.js';
+ * @import {CommitteeElectorateCreatorFacet, start as CommitteeStart} from '@agoric/governance/src/committee.js';
+ * @import {BootstrapPowers, Producer} from '../core/types.js';
+ */
+
+const trace = makeTracer('RunEconCommittee', true);
+
+/** @type {(name: string) => string} */
+const sanitizePathSegment = name => {
+  const candidate = name.replace(/[ ,]/g, '_');
+  assertPathSegment(candidate);
+  return candidate;
+};
+
+/**
+ * @typedef {object} EconCommitteeOptions
+ * @property {string} [committeeName]
+ * @property {number} [committeeSize]
+ */
+
+/**
+ * Start the Economic Committee electorate. Formerly part of
+ * `inter-protocol`; relocated to `@agoric/vats` because it outlives
+ * Inter Protocol — provisionPool (in this package) is governed and needs this
+ * electorate. The committee contract itself remains in `@agoric/governance`.
+ *
+ * @param {BootstrapPowers & {
+ *   produce: {
+ *     economicCommitteeKit: Producer<
+ *       StartedInstanceKit<typeof CommitteeStart> & { label: string }
+ *     >;
+ *     economicCommitteeCreatorFacet: Producer<CommitteeElectorateCreatorFacet>;
+ *   };
+ *   instance: {
+ *     produce: { economicCommittee: Producer<Instance<typeof CommitteeStart>> };
+ *   };
+ * }} powers
+ * @param {object} config
+ * @param {object} [config.options]
+ * @param {EconCommitteeOptions} [config.options.econCommitteeOptions]
+ */
+export const startEconomicCommittee = async (
+  {
+    consume: { board, chainStorage, diagnostics, zoe },
+    produce: { economicCommitteeKit, economicCommitteeCreatorFacet },
+    installation: {
+      consume: { committee },
+    },
+    instance: {
+      produce: { economicCommittee },
+    },
+  },
+  { options: { econCommitteeOptions = {} } = {} },
+) => {
+  const COMMITTEES_ROOT = 'committees';
+  trace('startEconomicCommittee');
+  const {
+    // NB: the electorate (and size) of the committee may change, but the name must not
+    committeeName = 'Economic Committee',
+    committeeSize = 3,
+    ...rest
+  } = econCommitteeOptions;
+
+  const committeesNode = await makeStorageNodeChild(
+    chainStorage,
+    COMMITTEES_ROOT,
+  );
+  const storageNode = await E(committeesNode).makeChildNode(
+    sanitizePathSegment(committeeName),
+  );
+
+  // NB: committee must only publish what it intended to be public
+  const marshaller = await E(board).getPublishingMarshaller();
+
+  const privateArgs = {
+    storageNode,
+    marshaller,
+  };
+  const startResult = await E(zoe).startInstance(
+    committee,
+    {},
+    { committeeName, committeeSize, ...rest },
+    privateArgs,
+    'economicCommittee',
+  );
+  const { creatorFacet, instance } = startResult;
+
+  economicCommitteeKit.resolve(
+    // XXX should startInstance return its label?
+    harden({ ...startResult, label: 'economicCommittee' }),
+  );
+
+  await E(diagnostics).savePrivateArgs(startResult.instance, privateArgs);
+
+  economicCommitteeCreatorFacet.resolve(creatorFacet);
+  economicCommittee.resolve(instance);
+};
+harden(startEconomicCommittee);
+
+export const ECON_COMMITTEE_MANIFEST = harden({
+  [startEconomicCommittee.name]: {
+    consume: {
+      board: true,
+      chainStorage: true,
+      diagnostics: true,
+      zoe: true,
+    },
+    produce: {
+      economicCommitteeKit: true,
+      economicCommitteeCreatorFacet: 'economicCommittee',
+    },
+    installation: {
+      consume: { committee: 'zoe' },
+    },
+    instance: {
+      produce: { economicCommittee: 'economicCommittee' },
+    },
+  },
+});
+
+// Core-eval manifest for the Economic Committee. Also publishes the governance
+// installations (contractGovernor, committee, binaryVoteCounter) that governed
+// contracts such as provisionPool depend on.
+export const getManifestForEconCommittee = (
+  { restoreRef },
+  { installKeys, econCommitteeOptions },
+) => {
+  return {
+    manifest: ECON_COMMITTEE_MANIFEST,
+    installations: {
+      contractGovernor: restoreRef(installKeys.contractGovernor),
+      committee: restoreRef(installKeys.committee),
+      binaryVoteCounter: restoreRef(installKeys.binaryVoteCounter),
+    },
+    options: {
+      econCommitteeOptions,
+    },
+  };
+};