@agoric/inter-protocol 0.13.2-dev-e61a41e.0 → 0.13.2-dev-d092592.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/inter-protocol",
-  "version": "0.13.2-dev-e61a41e.0+e61a41e",
+  "version": "0.13.2-dev-d092592.0+d092592",
   "description": "Core cryptoeconomy contracts",
   "type": "module",
   "main": "src/index.js",
@@ -29,17 +29,17 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/assert": "0.5.2-dev-e61a41e.0+e61a41e",
-    "@agoric/ertp": "0.15.4-dev-e61a41e.0+e61a41e",
-    "@agoric/governance": "0.9.2-dev-e61a41e.0+e61a41e",
-    "@agoric/internal": "0.2.2-dev-e61a41e.0+e61a41e",
+    "@agoric/assert": "0.5.2-dev-d092592.0+d092592",
+    "@agoric/ertp": "0.15.4-dev-d092592.0+d092592",
+    "@agoric/governance": "0.9.2-dev-d092592.0+d092592",
+    "@agoric/internal": "0.2.2-dev-d092592.0+d092592",
     "@agoric/nat": "^4.1.0",
-    "@agoric/notifier": "0.5.2-dev-e61a41e.0+e61a41e",
-    "@agoric/store": "0.8.4-dev-e61a41e.0+e61a41e",
-    "@agoric/swingset-vat": "0.30.3-dev-e61a41e.0+e61a41e",
-    "@agoric/vat-data": "0.4.4-dev-e61a41e.0+e61a41e",
-    "@agoric/vats": "0.13.1-dev-e61a41e.0+e61a41e",
-    "@agoric/zoe": "0.25.4-dev-e61a41e.0+e61a41e",
+    "@agoric/notifier": "0.5.2-dev-d092592.0+d092592",
+    "@agoric/store": "0.8.4-dev-d092592.0+d092592",
+    "@agoric/swingset-vat": "0.30.3-dev-d092592.0+d092592",
+    "@agoric/vat-data": "0.4.4-dev-d092592.0+d092592",
+    "@agoric/vats": "0.13.1-dev-d092592.0+d092592",
+    "@agoric/zoe": "0.25.4-dev-d092592.0+d092592",
     "@endo/bundle-source": "^2.4.2",
     "@endo/captp": "^2.0.18",
     "@endo/eventual-send": "^0.16.8",
@@ -49,9 +49,9 @@
     "@endo/promise-kit": "^0.2.52"
   },
   "devDependencies": {
-    "@agoric/cosmic-swingset": "0.39.3-dev-e61a41e.0+e61a41e",
-    "@agoric/deploy-script-support": "0.9.5-dev-e61a41e.0+e61a41e",
-    "@agoric/smart-wallet": "0.4.3-dev-e61a41e.0+e61a41e",
+    "@agoric/cosmic-swingset": "0.39.3-dev-d092592.0+d092592",
+    "@agoric/deploy-script-support": "0.9.5-dev-d092592.0+d092592",
+    "@agoric/smart-wallet": "0.4.3-dev-d092592.0+d092592",
     "@endo/init": "^0.5.52",
     "@fast-check/ava": "^1.0.1",
     "ava": "^5.0.1",
@@ -78,5 +78,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "e61a41e501c1964013df94c61f8ec6c092a83c5b"
+  "gitHead": "d0925925fe4c47daf823a4e34aad95869dbd22ed"
 }

package/scripts/build-bundles.js

@@ -25,7 +25,10 @@ await extractProposalBundles(
 await createBundles(
   [
     ['../src/psm/psm.js', '../bundles/bundle-psm.js'],
-    ['../src/psm/psmCharter.js', '../bundles/bundle-psmCharter.js'],
+    [
+      '../src/econCommitteeCharter.js',
+      '../bundles/bundle-econCommitteeCharter.js',
+    ],
   ],
   dirname,
 );

package/scripts/start-local-chain-config.json

@@ -51,8 +51,8 @@
         "psm": {
             "sourceSpec": "@agoric/inter-protocol/src/psm/psm.js"
         },
-        "psmCharter": {
-            "sourceSpec": "@agoric/inter-protocol/src/psm/psmCharter.js"
+        "econCommitteeCharter": {
+            "sourceSpec": "@agoric/inter-protocol/src/econCommitteeCharter.js"
         },
         "priceAggregator": {
             "sourceSpec": "@agoric/zoe/src/contracts/priceAggregator.js"

package/src/econCommitteeCharter.js

@@ -1,100 +1,132 @@
 import '@agoric/governance/exported.js';
+import { makeScalarMapStore, M, makeHeapFarInstance, fit } from '@agoric/store';
 import '@agoric/zoe/exported.js';
 import '@agoric/zoe/src/contracts/exported.js';
-
-import { E, Far } from '@endo/far';
+import { InstanceHandleShape } from '@agoric/zoe/src/typeGuards.js';
+import { TimestampShape } from '@agoric/swingset-vat/src/vats/timer/typeGuards.js';
+import { E } from '@endo/far';
 
 /**
  * @file
  *
- * This extremely quick and dirty contract simplifies the process of
- * calling for votes on changes to the economy by gathering the governor creator
- * facets in one place and invokes `voteOnParamChanges` and
- * `voteOnApiInvocation` on each when requested. A cleaner version would
- * validate parameters, constrain deadlines and probably split the ability to
- * call for vote into separate capabilities for finer grain encapsulation.
+ * This contract makes it possible for those who govern contracts to call for
+ * votes on changes. A more complete implementation would validate parameters,
+ * constrain deadlines and possibly split the ability to call for votes into
+ * separate capabilities for finer grain encapsulation.
+ */
+
+export const INVITATION_MAKERS_DESC = 'charter member invitation';
+
+/**
+ * @typedef {object} ParamChangesOfferArgs
+ * @property {bigint} deadline
+ * @property {Instance} instance
+ * @property {Record<string, unknown>} params
+ * @property {{paramPath: { key: string }}} [path]
  */
+const ParamChangesOfferArgsShape = harden(
+  M.split(
+    {
+      deadline: TimestampShape,
+      instance: InstanceHandleShape,
+      params: M.recordOf(M.string(), M.any()),
+    },
+    M.partial({
+      path: { paramPath: { key: M.any() } },
+    }),
+  ),
+);
 
 /**
  * @param {ZCF<{binaryVoteCounterInstallation:Installation}>} zcf
- * @param {{reserve:GovernedContractFacetAccess<{},{}>, amm:GovernedCreatorFacet<{}>, vaults:GovernedCreatorFacet<{}>}} privateArgs
  */
-export const start = async (zcf, privateArgs) => {
+export const start = async zcf => {
   const { binaryVoteCounterInstallation: counter } = zcf.getTerms();
-  const { reserve, amm, vaults } = privateArgs;
+  /** @type {MapStore<Instance,GovernedContractFacetAccess<{},{}>>} */
+  const instanceToGovernor = makeScalarMapStore();
+
+  const makeParamInvitation = () => {
+    /**
+     * @param {ZCFSeat} seat
+     * @param {ParamChangesOfferArgs} args
+     */
+    const voteOnParamChanges = (seat, args) => {
+      fit(args, ParamChangesOfferArgsShape);
+      seat.exit();
+
+      const {
+        params,
+        instance,
+        deadline,
+        path = { paramPath: { key: 'governedApi' } },
+      } = args;
+      const governor = instanceToGovernor.get(instance);
+      return E(governor).voteOnParamChanges(counter, deadline, {
+        ...path,
+        changes: params,
+      });
+    };
 
-  /**
-   * @param {*} target
-   * @param {Record<string, unknown>} params
-   * @param {bigint} deadline
-   * @param {{paramPath: { key: unknown }}} [path]
-   */
-  const voteOnParamChanges = (
-    target,
-    params,
-    deadline,
-    path = { paramPath: { key: 'governedApi' } },
-  ) => {
-    return E(target).voteOnParamChanges(counter, deadline, {
-      ...path,
-      changes: params,
-    });
+    return zcf.makeInvitation(voteOnParamChanges, 'vote on param changes');
   };
 
-  /**
-   * @param {*} target
-   * @param {string} method
-   * @param {unknown[]} args
-   * @param {bigint} deadline
-   */
-  const voteOnApiInvocation = (target, method, args, deadline) => {
-    return E(target).voteOnApiInvocation(method, args, counter, deadline);
+  const makeOfferFilterInvitation = (instance, strings, deadline) => {
+    const voteOnOfferFilterHandler = seat => {
+      seat.exit();
+
+      const governor = instanceToGovernor.get(instance);
+      return E(governor).voteOnOfferFilter(counter, deadline, strings);
+    };
+
+    return zcf.makeInvitation(voteOnOfferFilterHandler, 'vote on offer filter');
   };
 
-  const makeNullInvitation = () => {
-    return zcf.makeInvitation(() => {}, 'econCommitteeCharter noop');
+  const MakerShape = M.interface('Charter InvitationMakers', {
+    VoteOnParamChange: M.call().returns(M.promise()),
+    VoteOnPauseOffers: M.call(
+      InstanceHandleShape,
+      M.arrayOf(M.string()),
+      TimestampShape,
+    ).returns(M.promise()),
+  });
+  const invitationMakers = makeHeapFarInstance(
+    'Charter Invitation Makers',
+    MakerShape,
+    {
+      VoteOnParamChange: makeParamInvitation,
+      VoteOnPauseOffers: makeOfferFilterInvitation,
+    },
+  );
+
+  const charterMemberHandler = seat => {
+    seat.exit();
+    return harden({ invitationMakers });
   };
 
-  const publicFacet = Far('votingAPI', {
-    /**
-     * @param {Record<string, unknown>} params
-     * @param {bigint} deadline
-     */
-    voteOnAmmParamChanges: (params, deadline) =>
-      voteOnParamChanges(amm, params, deadline),
-    /**
-     * @param {Record<string, unknown>} params
-     * @param {bigint} deadline
-     */
-    voteOnReserveParamChanges: (params, deadline) =>
-      voteOnParamChanges(reserve, params, deadline),
-    /**
-     * vote on param changes for a vaultManager
-     *
-     * @param {Record<string, unknown>} params
-     * @param {{collateralBrand: Brand}} brand
-     * @param {bigint} deadline
-     */
-    voteOnVaultParamChanges: (params, brand, deadline) =>
-      voteOnParamChanges(vaults, params, deadline, {
-        paramPath: { key: brand },
-      }),
-    /**
-     * vote on param changes across the vaultFactory
-     *
-     * @param {Record<string, unknown>} params
-     * @param {bigint} deadline
-     */
-    voteOnVaultFactoryParamChanges: (params, deadline) =>
-      voteOnParamChanges(vaults, params, deadline),
-    /**
-     * @param {Amount[]} amounts
-     * @param {bigint} deadline
-     */
-    voteOnReserveApiInvocation: (amounts, deadline) =>
-      voteOnApiInvocation(reserve, 'addLiquidityToAmmPool', amounts, deadline),
-    makeNullInvitation,
+  const charterCreatorI = M.interface('Charter creatorFacet', {
+    addInstance: M.call(InstanceHandleShape, M.any())
+      .optional(M.string())
+      .returns(),
+    makeCharterMemberInvitation: M.call().returns(M.promise()),
   });
 
-  return harden({ publicFacet });
+  const creatorFacet = makeHeapFarInstance(
+    'Charter creatorFacet',
+    charterCreatorI,
+    {
+      /**
+       * @param {Instance} governedInstance
+       * @param {GovernedContractFacetAccess<{},{}>} governorFacet
+       * @param {string} [label] for diagnostic use only
+       */
+      addInstance: (governedInstance, governorFacet, label) => {
+        console.log('charter: adding instance', label);
+        instanceToGovernor.init(governedInstance, governorFacet);
+      },
+      makeCharterMemberInvitation: () =>
+        zcf.makeInvitation(charterMemberHandler, INVITATION_MAKERS_DESC),
+    },
+  );
+
+  return harden({ creatorFacet });
 };

package/src/proposals/committee-proposal.js

@@ -22,12 +22,17 @@ export const inviteCommitteeMembers = async (
       ammGovernorCreatorFacet,
       vaultFactoryGovernorCreator,
     },
+    produce: { econCharterStartResult },
     installation: {
       consume: { binaryVoteCounter: counterP },
     },
+    instance: {
+      consume: { amm, reserve, VaultFactory },
+    },
   },
   { options: { voterAddresses } },
 ) => {
+  // FIXME: why doesn't this use the promise space?
   /** @type {[Installation, Installation]} */
   const [charterInstall, counterInstall] = await Promise.all([
     E(agoricNames).lookup('installation', 'econCommitteeCharter'),
@@ -38,13 +43,25 @@ export const inviteCommitteeMembers = async (
       binaryVoteCounterInstallation: counterInstall,
     }),
   );
-  const privateFacets = {
-    reserve: reserveGovernorCreatorFacet,
-    amm: ammGovernorCreatorFacet,
-    vaults: vaultFactoryGovernorCreator,
-  };
-  const { publicFacet: votingAPI } = E.get(
-    E(zoe).startInstance(charterInstall, undefined, terms, privateFacets),
+  /** @type {Promise<import('./econ-behaviors').EconCharterStartResult>} */
+  const startResult = E(zoe).startInstance(charterInstall, undefined, terms);
+  const { creatorFacet } = E.get(startResult);
+  econCharterStartResult.resolve(startResult);
+
+  // Introduce charter to governed creator facets.
+  await Promise.all(
+    [
+      { instanceP: amm, facetP: ammGovernorCreatorFacet },
+      { instanceP: reserve, facetP: reserveGovernorCreatorFacet },
+      {
+        instanceP: VaultFactory,
+        facetP: vaultFactoryGovernorCreator,
+      },
+    ].map(async ({ instanceP, facetP }) => {
+      const [instance, govFacet] = await Promise.all([instanceP, facetP]);
+
+      return E(creatorFacet).addInstance(instance, govFacet);
+    }),
   );
 
   const invitations = await E(
@@ -60,7 +77,7 @@ export const inviteCommitteeMembers = async (
       addrInvitations.map(async ([addr, invitationP]) => {
         const [voterInvitation, nullInvitation] = await Promise.all([
           invitationP,
-          E(votingAPI).makeNullInvitation(),
+          E(creatorFacet).makeCharterMemberInvitation(),
         ]);
         await reserveThenDeposit(
           `econ committee member ${addr}`,
@@ -85,6 +102,7 @@ export const getManifestForInviteCommittee = async (
   return {
     manifest: {
       [inviteCommitteeMembers.name]: {
+        produce: { econCharterStartResult: t },
         consume: {
           zoe: t,
           agoricNames: t,
@@ -97,6 +115,9 @@ export const getManifestForInviteCommittee = async (
         installation: {
           consume: { binaryVoteCounter: t },
         },
+        instance: {
+          consume: { amm: t, reserve: t, VaultFactory: t },
+        },
       },
     },
     installations: {

package/src/proposals/econ-behaviors.js

@@ -56,8 +56,7 @@ const MILLI = 1_000_000n;
  *   periodicFeeCollectors: import('../feeDistributor.js').PeriodicFeeCollector[],
  *   bankMints: Mint[],
  *   psmFacets: MapStore<Brand, PSMFacets>,
- *   psmCharterCreatorFacet: Awaited<ReturnType<import('../psm/psmCharter.js').start>>['creatorFacet'],
- *   psmCharterAdminFacet: AdminFacet,
+ *   econCharterStartResult: EconCharterStartResult,
  *   reservePublicFacet: import('../reserve/assetReserve.js').AssetReservePublicFacet,
  *   reserveCreatorFacet: import('../reserve/assetReserve.js').AssetReserveLimitedCreatorFacet,
  *   reserveGovernorCreatorFacet: GovernedAssetReserveFacetAccess,
@@ -69,6 +68,14 @@ const MILLI = 1_000_000n;
  * }>} EconomyBootstrapSpace
  */
 
+/**
+ * @param {ERef<ZoeService>} zoe
+ * @param {Installation<import('../econCommitteeCharter').start>} inst
+ * @typedef {Awaited<ReturnType<typeof startCharterInstance>>} EconCharterStartResult
+ */
+// eslint-disable-next-line no-unused-vars
+const startCharterInstance = (zoe, inst) => E(zoe).startInstance(inst);
+
 /**
  * @file A collection of productions, each of which declares inputs and outputs.
  * Each function is passed a set of powers for reading from and writing to the vat config.

package/src/proposals/startPSM.js

@@ -32,7 +32,7 @@ export const startPSM = async (
       zoe,
       feeMintAccess: feeMintAccessP,
       economicCommitteeCreatorFacet,
-      psmCharterCreatorFacet,
+      econCharterStartResult,
       provisionPoolStartResult,
       chainStorage,
       chainTimerService,
@@ -174,11 +174,10 @@ export const startPSM = async (
 
   await Promise.all([
     E(instanceAdmin).update(instanceKey, newPsmFacets.psm),
-    E(psmCharterCreatorFacet).addInstance(
+    E(E.get(econCharterStartResult).creatorFacet).addInstance(
       psm,
       governorFacets.creatorFacet,
-      anchorBrand,
-      minted,
+      instanceKey,
     ),
     // @ts-expect-error TODO type for provisionPoolStartResult
     E(E.get(provisionPoolStartResult).creatorFacet).initPSM(
@@ -276,7 +275,7 @@ export const installGovAndPSMContracts = async ({
       committee,
       binaryVoteCounter,
       psm,
-      psmCharter,
+      econCommitteeCharter,
     },
   },
 }) => {
@@ -292,7 +291,7 @@ export const installGovAndPSMContracts = async ({
       committee,
       binaryVoteCounter,
       psm,
-      psmCharter,
+      econCommitteeCharter,
     }).map(async ([name, producer]) => {
       const bundleCap = D(vatAdmin).getNamedBundleCap(name);
       const bundle = D(bundleCap).getBundle();
@@ -303,15 +302,18 @@ export const installGovAndPSMContracts = async ({
   );
 };
 
-/** @param {EconomyBootstrapPowers} powers */
+/**
+ * @deprecated the PSM charter has been merged with the econ charter
+ * @param {EconomyBootstrapPowers} powers
+ */
 export const startPSMCharter = async ({
   consume: { zoe },
-  produce: { psmCharterCreatorFacet, psmCharterAdminFacet },
+  produce: { econCharterStartResult },
   installation: {
-    consume: { binaryVoteCounter, psmCharter: installP },
+    consume: { binaryVoteCounter, econCommitteeCharter: installP },
   },
   instance: {
-    produce: { psmCharter: instanceP },
+    produce: { econCommitteeCharter: instanceP },
   },
 }) => {
   const [charterR, counterR] = await Promise.all([installP, binaryVoteCounter]);
@@ -320,8 +322,7 @@ export const startPSMCharter = async ({
   const facets = await E(zoe).startInstance(charterR, {}, terms);
 
   instanceP.resolve(facets.instance);
-  psmCharterCreatorFacet.resolve(facets.creatorFacet);
-  psmCharterAdminFacet.resolve(facets.adminFacet);
+  econCharterStartResult.resolve(facets);
 };
 
 /**
@@ -343,21 +344,20 @@ export const PSM_GOV_MANIFEST = {
         committee: 'zoe',
         binaryVoteCounter: 'zoe',
         psm: 'zoe',
-        psmCharter: 'zoe',
+        econCommitteeCharter: 'zoe',
       },
     },
   },
   [startPSMCharter.name]: {
     consume: { zoe: 'zoe' },
     produce: {
-      psmCharterCreatorFacet: 'psmCharter',
-      psmCharterAdminFacet: 'psmCharter',
+      econCharterStartResult: 'econCommitteeCharter',
     },
     installation: {
-      consume: { binaryVoteCounter: 'zoe', psmCharter: 'zoe' },
+      consume: { binaryVoteCounter: 'zoe', econCommitteeCharter: 'zoe' },
     },
     instance: {
-      produce: { psmCharter: 'psmCharter' },
+      produce: { econCommitteeCharter: 'econCommitteeCharter' },
     },
   },
 };
@@ -374,7 +374,7 @@ export const invitePSMCommitteeMembers = async (
     consume: {
       namesByAddressAdmin,
       economicCommitteeCreatorFacet,
-      psmCharterCreatorFacet,
+      econCharterStartResult,
     },
   },
   { options: { voterAddresses = {} } },
@@ -392,7 +392,9 @@ export const invitePSMCommitteeMembers = async (
       addrInvitations.map(async ([addr, invitationP]) => {
         const [voterInvitation, charterMemberInvitation] = await Promise.all([
           invitationP,
-          E(psmCharterCreatorFacet).makeCharterMemberInvitation(),
+          E(
+            E.get(econCharterStartResult).creatorFacet,
+          ).makeCharterMemberInvitation(),
         ]);
         console.log('sending charter, voting invitations to', addr);
         await reserveThenDeposit(
@@ -416,7 +418,7 @@ export const INVITE_PSM_COMMITTEE_MANIFEST = harden({
     consume: {
       namesByAddressAdmin: true,
       economicCommitteeCreatorFacet: true,
-      psmCharterCreatorFacet: true,
+      econCharterStartResult: true,
     },
   },
 });
@@ -444,7 +446,7 @@ export const PSM_MANIFEST = harden({
       feeMintAccess: 'zoe',
       economicCommitteeCreatorFacet: 'economicCommittee',
       provisionPoolStartResult: true,
-      psmCharterCreatorFacet: 'psmCharter',
+      econCharterStartResult: 'econCommitteeCharter',
       chainTimerService: 'timer',
       psmFacets: true,
     },