@agoric/inter-protocol 0.13.4-dev-d32a66a.0 → 0.13.4-pismo-dev-f760927.0

package/src/proposals/utils.js

@@ -1,17 +1,19 @@
-import { WalletName } from '@agoric/internal';
 import { getCopyMapEntries, makeCopyMap } from '@agoric/store';
 import { E } from '@endo/far';
 
-const { Fail } = assert;
+// must match packages/wallet/api/src/lib-wallet.js
+export const DEPOSIT_FACET = 'depositFacet';
+
+const { details: X } = assert;
 
 /**
- * @param {ERef<import('@agoric/vats').NameAdmin>} nameAdmin
+ * @param {ERef<NameAdmin>} nameAdmin
  * @param {string[][]} paths
  */
 export const reserveThenGetNamePaths = async (nameAdmin, paths) => {
   /**
    *
-   * @param {ERef<import('@agoric/vats').NameAdmin>} nextAdmin
+   * @param {ERef<NameAdmin>} nextAdmin
    * @param {string[]} path
    */
   const nextPath = async (nextAdmin, path) => {
@@ -34,14 +36,14 @@ export const reserveThenGetNamePaths = async (nameAdmin, paths) => {
 
   return Promise.all(
     paths.map(async path => {
-      Array.isArray(path) || Fail`path ${path} is not an array`;
+      assert(Array.isArray(path), X`path ${path} is not an array`);
       return nextPath(nameAdmin, path);
     }),
   );
 };
 
 /**
- * @param {ERef<import('@agoric/vats').NameAdmin>} nameAdmin
+ * @param {ERef<NameAdmin>} nameAdmin
  * @param {string[]} names
  */
 export const reserveThenGetNames = async (nameAdmin, names) =>
@@ -50,36 +52,22 @@ export const reserveThenGetNames = async (nameAdmin, names) =>
     names.map(name => [name]),
   );
 
-/**
- * @param {string} debugName
- * @param {ERef<import('@agoric/vats').NameAdmin>} namesByAddressAdmin
- * @param {string} addr
- * @param {Array<ERef<Payment>>} payments
- */
 export const reserveThenDeposit = async (
   debugName,
   namesByAddressAdmin,
   addr,
   payments,
 ) => {
-  console.info('awaiting depositFacet for', debugName);
+  console.info('waiting for', debugName);
   const [depositFacet] = await reserveThenGetNamePaths(namesByAddressAdmin, [
-    [addr, WalletName.depositFacet],
+    [addr, DEPOSIT_FACET],
   ]);
   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,
-      );
-    }),
-  );
+  await Promise.all(payments.map(payment => E(depositFacet).receive(payment)));
+  console.info('confirmed deposit for', debugName);
 };
 
-/** @type {<T>(store: ERef<Map<string, T> | import('@agoric/internal/src/scratch.js').ScratchPad>, key: string, make: () => T) => Promise<T>} */
+/** @type {<T>(store: ERef<MapStore>, key: string, make: () => T) => Promise<T>} */
 const provideWhen = async (store, key, make) => {
   const found = await E(store).get(key);
   if (found) {
@@ -91,7 +79,8 @@ const provideWhen = async (store, key, make) => {
 };
 
 /**
- * @param {{ scratch: ERef<import('@agoric/internal/src/scratch.js').ScratchPad> }} homeP
+ *
+ * @param {{ scratch: ERef<MapStore<string, unknown>> }} homeP
  * @param {object} opts
  * @param {(specifier: string) => Promise<{default: Bundle}>} opts.loadBundle
  * @param {string} [opts.installCacheKey]
@@ -119,12 +108,9 @@ export const makeInstallCache = async (
   };
 
   const wrapInstall = install => async (mPath, bPath, opts) => {
-    const bundle = await loadBundle(bPath).then(m => m.default);
-    assert(
-      'endoZipBase64Sha512' in bundle,
-      'bundle must be EndoZipBase64Bundle',
+    const { endoZipBase64Sha512: sha512 } = await loadBundle(bPath).then(
+      m => m.default,
     );
-    const { endoZipBase64Sha512: sha512 } = bundle;
     const detail = await provideWhen(working, sha512, () =>
       install(mPath, bPath, opts).then(installation => ({
         installation,

package/src/psm/psm.js

@@ -1,43 +1,27 @@
-// @jessie-check
-
-import '@agoric/governance/exported.js';
+// @ts-check
 import '@agoric/zoe/exported.js';
 import '@agoric/zoe/src/contracts/exported.js';
+import '@agoric/governance/src/exported.js';
 
-import { AmountMath, AmountShape, BrandShape, RatioShape } from '@agoric/ertp';
-import {
-  CONTRACT_ELECTORATE,
-  handleParamGovernance,
-  ParamTypes,
-  publicMixinAPI,
-} from '@agoric/governance';
-import { StorageNodeShape } from '@agoric/internal';
-import { M, prepareExo, provide } from '@agoric/vat-data';
+import { E } from '@endo/eventual-send';
 import {
-  atomicRearrange,
-  atomicTransfer,
   ceilMultiplyBy,
   floorDivideBy,
   floorMultiplyBy,
-  makeRecorderTopic,
-  prepareRecorderKitMakers,
-  provideAll,
-  provideEmptySeat,
-  TopicsRecordShape,
 } from '@agoric/zoe/src/contractSupport/index.js';
+import { Far } from '@endo/marshal';
 import {
-  AmountKeywordRecordShape,
-  FeeMintAccessShape,
-  InstanceHandleShape,
-  InvitationShape,
-} from '@agoric/zoe/src/typeGuards.js';
-import { E } from '@endo/eventual-send';
+  handleParamGovernance,
+  ParamTypes,
+  publicMixinAPI,
+} from '@agoric/governance';
+import { M, provide, vivifyFarInstance } from '@agoric/vat-data';
+import { AmountMath } from '@agoric/ertp';
 
-import { mustMatch } from '@agoric/store';
-import { makeCollectFeesInvitation } from '../collectFees.js';
-import { makeNatAmountShape } from '../contractSupport.js';
+import { makeMakeCollectFeesInvitation } from '../collectFees.js';
+import { makeMetricsPublishKit } from '../contractSupport.js';
 
-const { Fail } = assert;
+const { details: X } = assert;
 
 /**
  * @file The Parity Stability Module supports efficiently minting/burning a
@@ -45,6 +29,7 @@ const { Fail } = assert;
  * thereby acts as an anchor to provide additional stability. For flexible
  * economic policies, the fee percentage for trading into and out of the stable
  * token are specified separately.
+ *
  */
 
 /**
@@ -54,8 +39,6 @@ const { Fail } = assert;
  *
  * @property {Amount<'nat'>} anchorPoolBalance  amount of Anchor token
  * available to be swapped
- * @property {Amount<'nat'>} mintedPoolBalance  amount of Minted token
- * outstanding (the amount minted minus the amount burned).
  * @property {Amount<'nat'>} feePoolBalance     amount of Minted token
  * fees available to be collected
  *
@@ -65,42 +48,22 @@ const { Fail } = assert;
  * ever given by this contract
  */
 
-/** @typedef {import('@agoric/vat-data').Baggage} Baggage */
-
-export const customTermsShape = {
-  anchorBrand: BrandShape,
-  anchorPerMinted: RatioShape,
-  electionManager: InstanceHandleShape,
-  governedParams: {
-    [CONTRACT_ELECTORATE]: {
-      type: ParamTypes.INVITATION,
-      value: AmountShape,
-    },
-    WantMintedFee: {
-      type: ParamTypes.RATIO,
-      value: RatioShape,
-    },
-    GiveMintedFee: {
-      type: ParamTypes.RATIO,
-      value: RatioShape,
-    },
-    MintLimit: { type: ParamTypes.AMOUNT, value: AmountShape },
-  },
+/**
+ * Stage a transfer of a single asset from one seat to another, with an optional
+ * remapping of the Keywords. Check that the remapping is for the same amount.
+ *
+ * @param {ZCFSeat} from
+ * @param {ZCFSeat} to
+ * @param {AmountKeywordRecord} txFrom
+ * @param {AmountKeywordRecord} txTo
+ */
+const stageTransfer = (from, to, txFrom, txTo = txFrom) => {
+  assert(AmountMath.isEqual(Object.values(txFrom)[0], Object.values(txTo)[0]));
+  from.decrementBy(txFrom);
+  to.incrementBy(txTo);
 };
-harden(customTermsShape);
 
-export const privateArgsShape = M.splitRecord(
-  harden({
-    marshaller: M.remotable('Marshaller'),
-    storageNode: StorageNodeShape,
-  }),
-  harden({
-    // only necessary on first invocation, not subsequent
-    feeMintAccess: FeeMintAccessShape,
-    initialPoserInvitation: InvitationShape,
-  }),
-);
-harden(privateArgsShape);
+/** @typedef {import('@agoric/vat-data').Baggage} Baggage */
 
 /**
  * @param {ZCF<GovernanceTerms<{
@@ -108,28 +71,26 @@ harden(privateArgsShape);
  *    WantMintedFee: 'ratio',
  *    MintLimit: 'amount',
  *   }> & {
- *    anchorBrand: Brand<'nat'>,
+ *    anchorBrand: Brand,
  *    anchorPerMinted: Ratio,
  * }>} zcf
  * @param {{feeMintAccess: FeeMintAccess, initialPoserInvitation: Invitation, storageNode: StorageNode, marshaller: Marshaller}} privateArgs
  * @param {Baggage} baggage
  */
-export const prepare = async (zcf, privateArgs, baggage) => {
+export const start = async (zcf, privateArgs, baggage) => {
   const { anchorBrand, anchorPerMinted } = zcf.getTerms();
   console.log('PSM Starting', anchorBrand, anchorPerMinted);
 
-  const { makeRecorderKit } = prepareRecorderKitMakers(
-    baggage,
-    privateArgs.marshaller,
+  const stableMint = await zcf.registerFeeMint(
+    'Minted',
+    privateArgs.feeMintAccess,
   );
-
-  const { stableMint } = await provideAll(baggage, {
-    stableMint: () => zcf.registerFeeMint('Minted', privateArgs.feeMintAccess),
-  });
   const { brand: stableBrand } = stableMint.getIssuerRecord();
-  (anchorPerMinted.numerator.brand === anchorBrand &&
-    anchorPerMinted.denominator.brand === stableBrand) ||
-    Fail`Ratio ${anchorPerMinted} is not consistent with brands ${anchorBrand} and ${stableBrand}`;
+  assert(
+    anchorPerMinted.numerator.brand === anchorBrand &&
+      anchorPerMinted.denominator.brand === stableBrand,
+    X`Ratio ${anchorPerMinted} is not consistent with brands ${anchorBrand} and ${stableBrand}`,
+  );
 
   zcf.setTestJig(() => ({
     stableIssuerRecord: stableMint.getIssuerRecord(),
@@ -137,7 +98,7 @@ export const prepare = async (zcf, privateArgs, baggage) => {
   const emptyStable = AmountMath.makeEmpty(stableBrand);
   const emptyAnchor = AmountMath.makeEmpty(anchorBrand);
 
-  const { publicMixin, makeDurableGovernorFacet, params } =
+  const { publicMixin, creatorMixin, makeFarGovernorFacet, params } =
     await handleParamGovernance(
       zcf,
       privateArgs.initialPoserInvitation,
@@ -150,113 +111,60 @@ export const prepare = async (zcf, privateArgs, baggage) => {
       privateArgs.marshaller,
     );
 
-  const anchorPool = provideEmptySeat(zcf, baggage, 'anchorPoolSeat');
-  const feePool = provideEmptySeat(zcf, baggage, 'feePoolSeat');
-  const stage = provideEmptySeat(zcf, baggage, 'stageSeat');
+  const provideEmptyZcfSeat = name => {
+    return provide(baggage, name, () => zcf.makeEmptySeatKit().zcfSeat);
+  };
 
-  // XXX access these through baggage directly so changes are saved
-  // Normally these would be in Exo class state but that's too big a change atm
-  provide(baggage, 'mintedPoolBalance', () =>
+  const anchorPool = provideEmptyZcfSeat('anchorPoolSeat');
+  const feePool = provideEmptyZcfSeat('feePoolSeat');
+  const stage = provideEmptyZcfSeat('stageSeat');
+
+  let mintedPoolBalance = provide(baggage, 'mintedPoolBalance', () =>
     AmountMath.makeEmpty(stableBrand),
   );
-  provide(baggage, 'totalAnchorProvided', () =>
+
+  let totalAnchorProvided = provide(baggage, 'totalAnchorProvided', () =>
     AmountMath.makeEmpty(anchorBrand),
   );
-  provide(baggage, 'totalMintedProvided', () =>
+  let totalMintedProvided = provide(baggage, 'totalMintedProvided', () =>
     AmountMath.makeEmpty(stableBrand),
   );
 
-  const { metricsKit } = await provideAll(baggage, {
-    metricsKit: () =>
-      E.when(E(privateArgs.storageNode).makeChildNode('metrics'), node =>
-        makeRecorderKit(
-          node,
-          /** @type {import('@agoric/zoe/src/contractSupport/recorder.js').TypedMatcher<MetricsNotification>} */ (
-            M.any()
-          ),
-        ),
-      ),
-  });
-  const topics = harden({
-    metrics: makeRecorderTopic('PSM metrics', metricsKit),
-  });
-
+  /** @type {import('../contractSupport.js').MetricsPublishKit<MetricsNotification>} */
+  const { metricsPublisher, metricsSubscriber } = makeMetricsPublishKit(
+    privateArgs.storageNode,
+    privateArgs.marshaller,
+  );
   const updateMetrics = () => {
-    void E(metricsKit.recorder).write(
+    metricsPublisher.publish(
       harden({
         anchorPoolBalance: anchorPool.getAmountAllocated('Anchor', anchorBrand),
         feePoolBalance: feePool.getAmountAllocated('Minted', stableBrand),
-        mintedPoolBalance: baggage.get('mintedPoolBalance'),
-        totalAnchorProvided: baggage.get('totalAnchorProvided'),
-        totalMintedProvided: baggage.get('totalMintedProvided'),
+        mintedPoolBalance,
+        totalAnchorProvided,
+        totalMintedProvided,
       }),
     );
   };
   updateMetrics();
 
-  const AnchorAmountShape = makeNatAmountShape(anchorBrand);
-  const StableAmountShape = makeNatAmountShape(stableBrand);
-
-  /**
-   * @param {ZCFSeat} seat
-   * @param {Omit<MetricsNotification, 'anchorPoolBalance'>} target
-   */
-  const restoreMetricsHook = (seat, target) => {
-    assert(
-      AmountMath.isEmpty(anchorPool.getAmountAllocated('Anchor', anchorBrand)),
-      'cannot restoreMetrics: anchorPool is not empty',
-    );
-    assert(
-      AmountMath.isEmpty(feePool.getAmountAllocated('Minted', stableBrand)),
-      'cannot restoreMetrics: feePool is not empty',
-    );
-    mustMatch(
-      target,
-      harden({
-        feePoolBalance: StableAmountShape,
-        mintedPoolBalance: StableAmountShape,
-        totalAnchorProvided: AnchorAmountShape,
-        totalMintedProvided: StableAmountShape,
-      }),
-    );
-    const {
-      give: { Anchor },
-    } = seat.getProposal();
-    stableMint.mintGains({ Minted: target.feePoolBalance }, feePool);
-    atomicTransfer(zcf, seat, anchorPool, { Anchor });
-    baggage.set('mintedPoolBalance', target.mintedPoolBalance);
-    baggage.set('totalAnchorProvided', target.totalAnchorProvided);
-    baggage.set('totalMintedProvided', target.totalMintedProvided);
-    seat.exit();
-    updateMetrics();
-  };
-
   /**
    * @param {Amount<'nat'>} toMint
    */
   const assertUnderLimit = toMint => {
-    const mintedAfter = AmountMath.add(
-      baggage.get('mintedPoolBalance'),
-      toMint,
-    );
+    const mintedAfter = AmountMath.add(mintedPoolBalance, toMint);
     AmountMath.isGTE(params.getMintLimit(), mintedAfter) ||
-      Fail`Request would exceed mint limit`;
+      assert.fail(X`Request would exceed mint limit`);
   };
 
   const burnMinted = toBurn => {
     stableMint.burnLosses({ Minted: toBurn }, stage);
-    baggage.set(
-      'mintedPoolBalance',
-      AmountMath.subtract(baggage.get('mintedPoolBalance'), toBurn),
-    );
+    mintedPoolBalance = AmountMath.subtract(mintedPoolBalance, toBurn);
   };
 
   const mintMinted = toMint => {
     stableMint.mintGains({ Minted: toMint }, stage);
-    baggage.set(
-      'mintedPoolBalance',
-      AmountMath.add(baggage.get('mintedPoolBalance'), toMint),
-    );
+    mintedPoolBalance = AmountMath.add(mintedPoolBalance, toMint);
   };
 
   /**
@@ -269,23 +177,26 @@ export const prepare = async (zcf, privateArgs, baggage) => {
     const afterFee = AmountMath.subtract(given, fee);
     const maxAnchor = floorMultiplyBy(afterFee, anchorPerMinted);
     AmountMath.isGTE(maxAnchor, wanted) ||
-      Fail`wanted ${wanted} is more than ${given} minus fees ${fee}`;
-    atomicRearrange(
-      zcf,
-      harden([
-        [seat, stage, { In: afterFee }, { Minted: afterFee }],
-        [seat, feePool, { In: fee }, { Minted: fee }],
-        [anchorPool, seat, { Anchor: maxAnchor }, { Out: maxAnchor }],
-      ]),
-    );
-    // The treatment of `burnMinted` here is different than the
-    // one immediately below. This `burnMinted`
-    // happen only if the `atomicRearrange` does *not* throw.
-    burnMinted(afterFee);
-    baggage.set(
-      'totalAnchorProvided',
-      AmountMath.add(baggage.get('totalAnchorProvided'), maxAnchor),
-    );
+      assert.fail(X`wanted ${wanted} is more than ${given} minus fees ${fee}`);
+    try {
+      stageTransfer(seat, stage, { In: afterFee }, { Minted: afterFee });
+      stageTransfer(seat, feePool, { In: fee }, { Minted: fee });
+      stageTransfer(
+        anchorPool,
+        seat,
+        { Anchor: maxAnchor },
+        { Out: maxAnchor },
+      );
+      zcf.reallocate(seat, anchorPool, stage, feePool);
+      burnMinted(afterFee);
+    } catch (e) {
+      stage.clear();
+      anchorPool.clear();
+      feePool.clear();
+      // TODO(#6116) someday, reallocate should guarantee that this case cannot happen
+      throw e;
+    }
+    totalAnchorProvided = AmountMath.add(totalAnchorProvided, maxAnchor);
   };
 
   /**
@@ -299,28 +210,22 @@ export const prepare = async (zcf, privateArgs, baggage) => {
     const fee = ceilMultiplyBy(asStable, params.getWantMintedFee());
     const afterFee = AmountMath.subtract(asStable, fee);
     AmountMath.isGTE(afterFee, wanted) ||
-      Fail`wanted ${wanted} is more than ${given} minus fees ${fee}`;
+      assert.fail(X`wanted ${wanted} is more than ${given} minus fees ${fee}`);
     mintMinted(asStable);
     try {
-      atomicRearrange(
-        zcf,
-        harden([
-          [seat, anchorPool, { In: given }, { Anchor: given }],
-          [stage, seat, { Minted: afterFee }, { Out: afterFee }],
-          [stage, feePool, { Minted: fee }],
-        ]),
-      );
+      stageTransfer(seat, anchorPool, { In: given }, { Anchor: given });
+      stageTransfer(stage, seat, { Minted: afterFee }, { Out: afterFee });
+      stageTransfer(stage, feePool, { Minted: fee });
+      zcf.reallocate(seat, anchorPool, stage, feePool);
     } catch (e) {
-      // The treatment of `burnMinted` here is different than the
-      // one immediately above. This `burnMinted`
-      // happens only if the `atomicRearrange` *does* throw.
+      stage.clear();
+      anchorPool.clear();
+      feePool.clear();
+      // TODO(#6116) someday, reallocate should guarantee that this case cannot happen
       burnMinted(asStable);
       throw e;
     }
-    baggage.set(
-      'totalMintedProvided',
-      AmountMath.add(baggage.get('totalMintedProvided'), asStable),
-    );
+    totalMintedProvided = AmountMath.add(totalMintedProvided, asStable);
   };
 
   /** @param {ZCFSeat} seat */
@@ -335,7 +240,7 @@ export const prepare = async (zcf, privateArgs, baggage) => {
   };
 
   /** @param {ZCFSeat} seat */
-  const wantMintedHook = seat => {
+  const wantmintedHook = seat => {
     const {
       give: { In: given },
       want: { Out: wanted } = { Out: undefined },
@@ -345,100 +250,83 @@ export const prepare = async (zcf, privateArgs, baggage) => {
     updateMetrics();
   };
 
-  const { anchorAmountShape, stableAmountShape } = await provideAll(baggage, {
-    anchorAmountShape: () => E(anchorBrand).getAmountShape(),
-    stableAmountShape: () => E(stableBrand).getAmountShape(),
+  const [anchorAmountShape, stableAmountShape] = await Promise.all([
+    E(anchorBrand).getAmountShape(),
+    E(stableBrand).getAmountShape(),
+  ]);
+
+  const PSMI = M.interface('PSM', {
+    getMetrics: M.call().returns(M.remotable('MetricsSubscriber')),
+    getPoolBalance: M.call().returns(anchorAmountShape),
+    makeWantMintedInvitation: M.call().returns(M.promise()),
+    makeGiveMintedInvitation: M.call().returns(M.promise()),
+    ...publicMixinAPI,
   });
 
-  const publicFacet = prepareExo(
+  const methods = {
+    getMetrics() {
+      return metricsSubscriber;
+    },
+    getPoolBalance() {
+      return anchorPool.getAmountAllocated('Anchor', anchorBrand);
+    },
+    makeWantMintedInvitation() {
+      return zcf.makeInvitation(
+        wantmintedHook,
+        'wantMinted',
+        undefined,
+        M.split({
+          give: { In: anchorAmountShape },
+          want: M.or({ Out: stableAmountShape }, {}),
+        }),
+      );
+    },
+    makeGiveMintedInvitation() {
+      return zcf.makeInvitation(
+        giveMintedHook,
+        'giveMinted',
+        undefined,
+        M.split({
+          give: { In: stableAmountShape },
+          want: M.or({ Out: anchorAmountShape }, {}),
+        }),
+      );
+    },
+    ...publicMixin,
+  };
+  const publicFacet = vivifyFarInstance(
     baggage,
     'Parity Stability Module',
-    M.interface('PSM', {
-      getMetrics: M.call().returns(M.remotable('MetricsSubscriber')),
-      getPoolBalance: M.call().returns(anchorAmountShape),
-      getPublicTopics: M.call().returns(TopicsRecordShape),
-      makeWantMintedInvitation: M.call().returns(M.promise()),
-      makeGiveMintedInvitation: M.call().returns(M.promise()),
-      ...publicMixinAPI,
-    }),
-    {
-      getMetrics() {
-        return metricsKit.subscriber;
-      },
-      getPoolBalance() {
-        return anchorPool.getAmountAllocated('Anchor', anchorBrand);
-      },
-      getPublicTopics() {
-        return topics;
-      },
-      makeWantMintedInvitation() {
-        return zcf.makeInvitation(
-          wantMintedHook,
-          'wantMinted',
-          undefined,
-          M.splitRecord({
-            give: { In: anchorAmountShape },
-            want: M.or({ Out: stableAmountShape }, {}),
-          }),
-        );
-      },
-      makeGiveMintedInvitation() {
-        return zcf.makeInvitation(
-          giveMintedHook,
-          'giveMinted',
-          undefined,
-          M.splitRecord({
-            give: { In: stableAmountShape },
-            want: M.or({ Out: anchorAmountShape }, {}),
-          }),
-        );
-      },
-      ...publicMixin,
-    },
+    PSMI,
+    methods,
   );
 
-  const limitedCreatorFacet = prepareExo(
-    baggage,
-    'PSM machine',
-    M.interface('PSM machine', {
-      getRewardAllocation: M.call().returns(AmountKeywordRecordShape),
-      makeCollectFeesInvitation: M.call().returns(
-        M.promise(/* InvitationShape */),
-      ),
-      makeRestoreMetricsInvitation: M.call().returns(
-        M.promise(/* InvitationShape */),
-      ),
-    }),
-    {
-      getRewardAllocation() {
-        return feePool.getCurrentAllocation();
-      },
-      makeCollectFeesInvitation() {
-        return makeCollectFeesInvitation(zcf, feePool, stableBrand, 'Minted');
-      },
-      makeRestoreMetricsInvitation() {
-        return zcf.makeInvitation(
-          restoreMetricsHook,
-          'restoreMetrics',
-          undefined,
-          M.splitRecord({
-            give: {
-              Anchor: AnchorAmountShape,
-            },
-          }),
-        );
-      },
-    },
+  // TODO why does this operation return an object with a single operation?
+  const { makeCollectFeesInvitation } = makeMakeCollectFeesInvitation(
+    zcf,
+    feePool,
+    stableBrand,
+    'Minted',
   );
 
-  const { governorFacet } = makeDurableGovernorFacet(
-    baggage,
-    limitedCreatorFacet,
-  );
+  // The creator facets are only accessibly to governance and bootstrap,
+  // and so do not need interface protection at this time. Additionally,
+  // all the operations take no arguments and so are largely defensive as is.
+  const limitedCreatorFacet = Far('Parity Stability Module', {
+    getRewardAllocation() {
+      return feePool.getCurrentAllocation();
+    },
+    makeCollectFeesInvitation() {
+      return makeCollectFeesInvitation();
+    },
+    ...creatorMixin,
+  });
+
+  const governorFacet = makeFarGovernorFacet(limitedCreatorFacet);
   return harden({
     creatorFacet: governorFacet,
     publicFacet,
   });
 };
 
-/** @typedef {Awaited<ReturnType<typeof prepare>>['publicFacet']} PsmPublicFacet */
+/** @typedef {Awaited<ReturnType<typeof start>>['publicFacet']} PsmPublicFacet */