@agoric/inter-protocol 0.13.2-dev-606cbd2.0 → 0.13.2-dev-8d17cce.0

package/src/proposals/core-proposal.js

@@ -10,6 +10,48 @@ export * from './econ-behaviors.js';
 export * from './startPSM.js'; // eslint-disable-line import/export
 export * from './startEconCommittee.js'; // eslint-disable-line import/export
 
+// XXX all the startInstance() should use startUpgradable()
+// or startGovernedUpgradeable() but that would
+// require updating a lot of tests. So for now, we just
+// grab the kits afterward and store them.
+
+/**
+ * @param {import('./econ-behaviors.js').EconomyBootstrapPowers} powers
+ */
+export const storeInterContractStartKits = async ({
+  consume: {
+    contractKits,
+    governedContractKits,
+    econCharterKit,
+    economicCommitteeKit,
+    feeDistributorKit,
+    auctioneerKit,
+    reserveKit,
+    vaultFactoryKit,
+  },
+}) => {
+  /**
+   * @param {Promise<MapStore<string, {instance: Instance}>>} storeP
+   * @param {Promise<{instance: Instance}>[]} kitPs
+   */
+  const storeAll = async (storeP, kitPs) => {
+    const store = await storeP;
+    const kits = await Promise.all(kitPs);
+    kits.forEach(kit => store.init(kit.instance, kit));
+  };
+
+  await storeAll(contractKits, [
+    economicCommitteeKit,
+    econCharterKit,
+    feeDistributorKit,
+  ]);
+  await storeAll(governedContractKits, [
+    auctioneerKit,
+    reserveKit,
+    vaultFactoryKit,
+  ]);
+};
+
 /** @type {import('@agoric/vats/src/core/lib-boot.js').BootstrapManifest} */
 const SHARED_MAIN_MANIFEST = harden({
   /** @type {import('@agoric/vats/src/core/lib-boot.js').BootstrapManifestPermit} */
@@ -17,6 +59,7 @@ const SHARED_MAIN_MANIFEST = harden({
     consume: {
       board: 'board',
       chainStorage: true,
+      diagnostics: true,
       feeMintAccess: 'zoe',
       chainTimerService: 'timer',
       zoe: 'zoe',
@@ -41,7 +84,6 @@ const SHARED_MAIN_MANIFEST = harden({
       },
       produce: {
         VaultFactory: 'VaultFactory',
-        Treasury: 'VaultFactory',
         VaultFactoryGovernor: 'VaultFactoryGovernor',
       },
     },
@@ -58,6 +100,7 @@ const SHARED_MAIN_MANIFEST = harden({
     consume: {
       board: 'board',
       chainStorage: true,
+      diagnostics: true,
       feeMintAccess: 'zoe',
       chainTimerService: 'timer',
       zoe: 'zoe',
@@ -98,12 +141,26 @@ const SHARED_MAIN_MANIFEST = harden({
       consume: { [Stable.symbol]: 'zoe' },
     },
   },
+
+  [storeInterContractStartKits.name]: {
+    consume: {
+      contractKits: true,
+      governedContractKits: true,
+      econCharterKit: true,
+      economicCommitteeKit: true,
+      feeDistributorKit: true,
+      auctioneerKit: true,
+      reserveKit: true,
+      vaultFactoryKit: true,
+    },
+  },
 });
 
 const REWARD_MANIFEST = harden({
   [econBehaviors.startRewardDistributor.name]: {
     consume: {
       chainTimerService: true,
+      diagnostics: true,
       bankManager: true,
       vaultFactoryKit: true,
       periodicFeeCollectors: true,

package/src/proposals/econ-behaviors.js

@@ -10,14 +10,15 @@ import '@agoric/vats/exported.js';
 import '@agoric/vats/src/core/types.js';
 import { Stable } from '@agoric/vats/src/tokens.js';
 import { E } from '@endo/far';
+import { makeScalarBigMapStore } from '@agoric/vat-data';
 import { makeGovernedTerms as makeGovernedATerms } from '../auction/params.js';
 import { makeReserveTerms } from '../reserve/params.js';
 import { makeGovernedTerms as makeGovernedVFTerms } from '../vaultFactory/params.js';
 
 const trace = makeTracer('RunEconBehaviors', false);
 
-const SECONDS_PER_HOUR = 60n * 60n;
-const SECONDS_PER_DAY = 24n * SECONDS_PER_HOUR;
+export const SECONDS_PER_HOUR = 60n * 60n;
+export const SECONDS_PER_DAY = 24n * SECONDS_PER_HOUR;
 
 /**
  * @typedef {import('../vaultFactory/vaultFactory.js').VaultFactoryContract['publicFacet']} VaultFactoryPublicFacet
@@ -27,6 +28,7 @@ const SECONDS_PER_DAY = 24n * SECONDS_PER_HOUR;
 
 /**
  * @typedef {object} PSMKit
+ * @property {string} label
  * @property {Instance} psm
  * @property {Instance} psmGovernor
  * @property {Awaited<ReturnType<Awaited<ReturnType<import('../psm/psm.js')['prepare']>>['creatorFacet']['getLimitedCreatorFacet']>>} psmCreatorFacet
@@ -44,14 +46,8 @@ const SECONDS_PER_DAY = 24n * SECONDS_PER_HOUR;
  * @typedef {PromiseSpaceOf<{
  *   economicCommitteeKit: CommitteeStartResult,
  *   economicCommitteeCreatorFacet: import('@agoric/governance/src/committee.js').CommitteeElectorateCreatorFacet,
- *   feeDistributorKit: {
- *     creatorFacet: import('../feeDistributor.js').FeeDistributorCreatorFacet,
- *     publicFacet: import('../feeDistributor.js').FeeDistributorPublicFacet,
- *     adminFacet: AdminFacet,
- *   },
- *   periodicFeeCollectors: import('../feeDistributor.js').PeriodicFeeCollector[],
- *   bankMints: Mint[],
- *   vBankKits: import('@agoric/zoe/src/zoeService/utils.js').StartedInstanceKit<any>[],
+ *   feeDistributorKit: StartedInstanceKit<typeof import('../feeDistributor.js').start>,
+ *   periodicFeeCollectors: MapStore<number, import('../feeDistributor.js').PeriodicFeeCollector>,
  *   psmKit: MapStore<Brand, PSMKit>,
  *   anchorBalancePayments: MapStore<Brand, Payment<'nat'>>,
  *   econCharterKit: EconCharterStartResult,
@@ -81,6 +77,7 @@ export const setupReserve = async ({
     feeMintAccess: feeMintAccessP,
     chainStorage,
     chainTimerService,
+    diagnostics,
     zoe,
     economicCommitteeCreatorFacet: committeeCreator,
   },
@@ -125,19 +122,20 @@ export const setupReserve = async ({
       },
     }),
   );
+  const privateArgs = {
+    governed: {
+      feeMintAccess,
+      initialPoserInvitation: poserInvitation,
+      marshaller,
+      storageNode,
+    },
+  };
   /** @type {GovernorStartedInstallationKit<typeof reserveInstallation>} */
   const g = await E(zoe).startInstance(
     governorInstallation,
     {},
     reserveGovernorTerms,
-    {
-      governed: {
-        feeMintAccess,
-        initialPoserInvitation: poserInvitation,
-        marshaller,
-        storageNode,
-      },
-    },
+    privateArgs,
     'reserve.governor',
   );
 
@@ -149,14 +147,19 @@ export const setupReserve = async ({
 
   reserveKit.resolve(
     harden({
+      label: 'AssetReserve',
       instance,
-      governor: g.instance,
       publicFacet,
       creatorFacet,
-      governorCreatorFacet: g.creatorFacet,
       adminFacet: g.adminFacet,
+
+      governor: g.instance,
+      governorCreatorFacet: g.creatorFacet,
+      governorAdminFacet: g.adminFacet,
     }),
   );
+  await E(diagnostics).savePrivateArgs(instance, privateArgs.governed);
+  await E(diagnostics).savePrivateArgs(g.instance, privateArgs);
 
   reserveInstanceProducer.resolve(instance);
   reserveGovernor.resolve(g.instance);
@@ -297,11 +300,7 @@ export const startVaultFactory = async (
   );
 
   /** @type {GovernorStartedInstallationKit<typeof vaultFactoryInstallation>} */
-  const {
-    creatorFacet: governorCreatorFacet,
-    instance: governorInstance,
-    adminFacet,
-  } = await E(consume.zoe).startInstance(
+  const g = await E(consume.zoe).startInstance(
     contractGovernorInstallation,
     undefined,
     governorTerms,
@@ -312,29 +311,40 @@ export const startVaultFactory = async (
     'vaultFactory.governor',
   );
 
-  const [vaultFactoryInstance, vaultFactoryCreator, publicFacet] =
+  const [vaultFactoryInstance, vaultFactoryCreator, publicFacet, adminFacet] =
     await Promise.all([
-      E(governorCreatorFacet).getInstance(),
-      E(governorCreatorFacet).getCreatorFacet(),
-      E(governorCreatorFacet).getPublicFacet(),
+      E(g.creatorFacet).getInstance(),
+      E(g.creatorFacet).getCreatorFacet(),
+      E(g.creatorFacet).getPublicFacet(),
+      E(g.creatorFacet).getAdminFacet(),
     ]);
 
+  // XXX omitting the governor
+  await E(consume.diagnostics).savePrivateArgs(
+    vaultFactoryInstance,
+    vaultFactoryPrivateArgs,
+  );
+
   vaultFactoryKit.resolve(
     harden({
+      label: 'VaultFactory',
       creatorFacet: vaultFactoryCreator,
-      governorCreatorFacet,
       adminFacet,
       publicFacet,
-      governor: governorInstance,
       instance: vaultFactoryInstance,
+
+      governor: g.instance,
+      governorAdminFacet: g.adminFacet,
+      governorCreatorFacet: g.creatorFacet,
+
+      // XXX try refactoring to use savePrivateArgs
       privateArgs: vaultFactoryPrivateArgs,
     }),
   );
 
   // Advertise the installations, instances in agoricNames.
   instanceProduce.VaultFactory.resolve(vaultFactoryInstance);
-  instanceProduce.Treasury.resolve(vaultFactoryInstance);
-  instanceProduce.VaultFactoryGovernor.resolve(governorInstance);
+  instanceProduce.VaultFactoryGovernor.resolve(g.instance);
 };
 
 /**
@@ -452,16 +462,14 @@ export const startRewardDistributor = async ({
   });
 
   feeDistributorKit.resolve(
-    harden({
-      creatorFacet: instanceKit.creatorFacet,
-      publicFacet: instanceKit.publicFacet,
-      adminFacet: instanceKit.adminFacet,
-    }),
+    harden({ ...instanceKit, label: 'feeDistributor' }),
   );
   feeDistributorP.resolve(instanceKit.instance);
 
   // Initialize the periodic collectors list if we don't have one.
-  periodicFeeCollectorsP.resolve([]);
+  periodicFeeCollectorsP.resolve(
+    makeScalarBigMapStore('periodicCollectors', { durable: true }),
+  );
   const periodicCollectors = await periodicFeeCollectors;
 
   const collectorKit = {
@@ -476,7 +484,7 @@ export const startRewardDistributor = async ({
       const periodicCollector = await E(
         instanceKit.creatorFacet,
       ).startPeriodicCollection(debugName, collector);
-      periodicCollectors.push(periodicCollector);
+      periodicCollectors.init(periodicCollectors.getSize(), periodicCollector);
     }),
   );
 };
@@ -514,13 +522,13 @@ export const startAuctioneer = async (
   },
   {
     auctionParams = {
-      StartFreq: 3600n,
+      StartFrequency: 3600n,
       ClockStep: 3n * 60n,
       StartingRate: 10500n,
-      LowestRate: 4500n,
+      LowestRate: 6500n,
       DiscountStep: 500n,
       AuctionStartDelay: 2n,
-      PriceLockPeriod: 300n,
+      PriceLockPeriod: 30n * 60n, // half an hour
     },
   } = {},
 ) => {
@@ -594,12 +602,15 @@ export const startAuctioneer = async (
 
   auctioneerKit.resolve(
     harden({
+      label: 'auctioneer',
       creatorFacet: governedCreatorFacet,
-      governorCreatorFacet: governorStartResult.creatorFacet,
       adminFacet: governorStartResult.adminFacet,
       publicFacet: governedPublicFacet,
-      governor: governorStartResult.instance,
       instance: governedInstance,
+
+      governor: governorStartResult.instance,
+      governorCreatorFacet: governorStartResult.creatorFacet,
+      governorAdminFacet: governorStartResult.adminFacet,
     }),
   );
 

package/src/proposals/price-feed-proposal.js

@@ -94,10 +94,8 @@ export const createPriceFeed = async (
       namesByAddressAdmin,
       priceAuthority,
       priceAuthorityAdmin,
-      startGovernedUpgradable: startGovernedUpgradableP,
-      fluxAggregatorKits,
+      startGovernedUpgradable,
     },
-    produce: { fluxAggregatorKits: produceFluxAggregatorKits },
   },
   {
     options: {
@@ -147,16 +145,13 @@ export const createPriceFeed = async (
   const label = sanitizePathSegment(AGORIC_INSTANCE_NAME);
 
   const storageNode = await makeStorageNodeChild(chainStorage, STORAGE_PATH);
-  const marshaller = E(board).getReadonlyMarshaller();
+  const marshaller = await E(board).getReadonlyMarshaller();
 
   trace('awaiting startInstance');
-  // Create the price feed.
-  const startGovernedUpgradable = await startGovernedUpgradableP;
-  produceFluxAggregatorKits.resolve([]);
-  const faKit = await startGovernedUpgradable({
+  const faKit = await E(startGovernedUpgradable)({
     governedParams: {},
     privateArgs: {
-      highPrioritySendersManager,
+      highPrioritySendersManager: await highPrioritySendersManager,
       marshaller,
       namesByAddressAdmin,
       storageNode: await E(storageNode).makeChildNode(label),
@@ -164,16 +159,13 @@ export const createPriceFeed = async (
     terms,
     label,
     installation: priceAggregator,
-    produceResults: {
-      resolve: kit =>
-        Promise.resolve(fluxAggregatorKits).then(kits => kits.push(kit)),
-    },
   });
 
-  E(E(agoricNamesAdmin).lookupAdmin('instance')).update(
-    AGORIC_INSTANCE_NAME,
-    faKit.instance,
-  );
+  E(E(agoricNamesAdmin).lookupAdmin('instance'))
+    .update(AGORIC_INSTANCE_NAME, faKit.instance)
+    .catch(err =>
+      console.error(`🚨 failed to update ${AGORIC_INSTANCE_NAME}`, err),
+    );
 
   E(E.get(econCharterKit).creatorFacet).addInstance(
     faKit.instance,
@@ -239,10 +231,6 @@ export const getManifestForPriceFeed = async (
         priceAuthority: t,
         priceAuthorityAdmin: t,
         startGovernedUpgradable: t,
-        fluxAggregatorKits: t,
-      },
-      produce: {
-        fluxAggregatorKits: t,
       },
     },
     [ensureOracleBrands.name]: {

package/src/proposals/startEconCommittee.js

@@ -28,7 +28,7 @@ const sanitizePathSegment = name => {
  */
 export const startEconomicCommittee = async (
   {
-    consume: { board, chainStorage, zoe },
+    consume: { board, chainStorage, diagnostics, zoe },
     produce: { economicCommitteeKit, economicCommitteeCreatorFacet },
     installation: {
       consume: { committee },
@@ -59,19 +59,26 @@ export const startEconomicCommittee = async (
   // 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 },
-    {
-      storageNode,
-      marshaller,
-    },
+    privateArgs,
     'economicCommittee',
   );
   const { creatorFacet, instance } = startResult;
 
-  economicCommitteeKit.resolve(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);
 };
@@ -82,6 +89,7 @@ export const ECON_COMMITTEE_MANIFEST = harden({
     consume: {
       board: true,
       chainStorage: true,
+      diagnostics: true,
       zoe: true,
     },
     produce: {

package/src/proposals/startPSM.js

@@ -7,9 +7,13 @@ import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
 import { makeRatio } from '@agoric/zoe/src/contractSupport/index.js';
 import { E } from '@endo/far';
 import { Stable } from '@agoric/vats/src/tokens.js';
-import { makeHistoryReviver } from '@agoric/vats/tools/board-utils.js';
+import {
+  makeHistoryReviver,
+  makeBoardRemote,
+  slotToBoardRemote,
+} from '@agoric/vats/tools/board-utils.js';
 import { deeplyFulfilledObject } from '@agoric/internal';
-import { makeScalarMapStore } from '@agoric/vat-data';
+import { makeScalarBigMapStore } from '@agoric/vat-data';
 
 import { reserveThenGetNamePaths } from './utils.js';
 
@@ -39,7 +43,10 @@ const stablePsmKey = `published.psm.${Stable.symbol}`;
 const findOldPSMState = (chainStorageEntries, keyword, brands) => {
   // In this reviver, object references are revived as boardIDs
   // from the pre-bulldozer board.
-  const toSlotReviver = makeHistoryReviver(chainStorageEntries);
+  const toSlotReviver = makeHistoryReviver(
+    chainStorageEntries,
+    slotToBoardRemote,
+  );
   if (!toSlotReviver.has(`${stablePsmKey}.${keyword}.metrics`)) {
     return {};
   }
@@ -47,12 +54,19 @@ const findOldPSMState = (chainStorageEntries, keyword, brands) => {
     `${stablePsmKey}.${keyword}.metrics`,
   );
   const oldIDtoNewBrand = makeMap([
-    [metricsWithOldBoardIDs.feePoolBalance.brand, brands.minted],
-    [metricsWithOldBoardIDs.anchorPoolBalance.brand, brands.anchor],
+    [metricsWithOldBoardIDs.feePoolBalance.brand.getBoardId(), brands.minted],
+    [
+      metricsWithOldBoardIDs.anchorPoolBalance.brand.getBoardId(),
+      brands.anchor,
+    ],
   ]);
-  // revive brands; other object references map to undefined
-  const brandReviver = makeHistoryReviver(chainStorageEntries, s =>
-    oldIDtoNewBrand.get(s),
+  // revive brands; other object references map to dummy remotables
+  const brandReviver = makeHistoryReviver(
+    chainStorageEntries,
+    (slotID, iface) => {
+      const newBrand = oldIDtoNewBrand.get(slotID);
+      return newBrand || makeBoardRemote({ boardId: slotID, iface });
+    },
   );
   return {
     metrics: brandReviver.getItem(`${stablePsmKey}.${keyword}.metrics`),
@@ -74,6 +88,7 @@ export const startPSM = async (
     consume: {
       agoricNamesAdmin,
       board,
+      diagnostics,
       zoe,
       feeMintAccess: feeMintAccessP,
       economicCommitteeCreatorFacet,
@@ -189,6 +204,12 @@ export const startPSM = async (
       },
     }),
   );
+  const psmPrivateArgs = {
+    feeMintAccess,
+    initialPoserInvitation,
+    marshaller,
+    storageNode,
+  };
   /** @type {GovernorStartedInstallationKit<typeof psmInstall>} */
   const governorFacets = await E(zoe).startInstance(
     contractGovernor,
@@ -196,12 +217,7 @@ export const startPSM = async (
     governorTerms,
     harden({
       economicCommitteeCreatorFacet,
-      governed: {
-        feeMintAccess,
-        initialPoserInvitation,
-        marshaller,
-        storageNode,
-      },
+      governed: psmPrivateArgs,
     }),
     `${instanceKey}.governor`,
   );
@@ -211,6 +227,7 @@ export const startPSM = async (
     E(governorFacets.creatorFacet).getCreatorFacet(),
     E(governorFacets.creatorFacet).getAdminFacet(),
   ]);
+  await E(diagnostics).savePrivateArgs(psm, psmPrivateArgs);
 
   /** @param {MetricsNotification} metrics */
   const restoreMetrics = async metrics => {
@@ -229,22 +246,23 @@ export const startPSM = async (
   };
   await (oldState.metrics && restoreMetrics(oldState.metrics));
 
-  /** @typedef {import('./econ-behaviors.js').PSMKit} psmKit */
-  /** @type {psmKit} */
-  const newpsmKit = {
+  /** @type {import('./econ-behaviors.js').PSMKit} */
+  const newpsmKit = harden({
+    label: instanceKey,
     psm,
     psmGovernor: governorFacets.instance,
     psmCreatorFacet,
     psmAdminFacet,
     psmGovernorCreatorFacet: governorFacets.creatorFacet,
-  };
+  });
 
   // Provide pattern with a promise.
-  producepsmKit.resolve(makeScalarMapStore());
+  producepsmKit.resolve(makeScalarBigMapStore('PSM Kits', { durable: true }));
 
-  /** @type {MapStore<Brand,psmKit>} */
+  /** @type {MapStore<Brand, import('./econ-behaviors.js').PSMKit>} */
   const psmKitMap = await psmKit;
 
+  // TODO init into governedContractKits too to simplify testing
   psmKitMap.init(anchorBrand, newpsmKit);
   const instanceAdmin = E(agoricNamesAdmin).lookupAdmin('instance');
 
@@ -290,16 +308,14 @@ export const makeAnchorAsset = async (
     consume: {
       agoricNamesAdmin,
       bankManager,
-      startUpgradable: startUpgradableP,
+      startUpgradable,
       anchorBalancePayments,
-      anchorKits,
     },
     installation: {
       consume: { mintHolder },
     },
     produce: {
       testFirstAnchorKit,
-      anchorKits: produceAnchorKits,
       anchorBalancePayments: produceAnchorBalancePayments,
     },
   },
@@ -329,35 +345,35 @@ export const makeAnchorAsset = async (
     }),
   );
 
-  const startUpgradable = await startUpgradableP;
-  produceAnchorKits.resolve([]);
   /** @type {{ creatorFacet: ERef<Mint<'nat'>>, publicFacet: ERef<Issuer<'nat'>> }} */
   // @ts-expect-error cast
-  const { creatorFacet: mint, publicFacet: issuerP } = await startUpgradable({
+  const { creatorFacet: mint, publicFacet: issuer } = await E(startUpgradable)({
     installation: mintHolder,
     label: keyword,
     terms,
-    privateArgs: undefined,
-    produceResults: {
-      resolve: kit => Promise.resolve(anchorKits).then(kits => kits.push(kit)),
-    },
   });
-  const issuer = await issuerP; // identity of issuers is important
 
   const brand = await E(issuer).getBrand();
-  const kit = { mint, issuer, brand };
+  const kit = harden({ mint, issuer, brand });
 
   testFirstAnchorKit.resolve(kit);
 
-  const toSlotReviver = makeHistoryReviver(chainStorageEntries);
+  const toSlotReviver = makeHistoryReviver(
+    chainStorageEntries,
+    slotToBoardRemote,
+  );
   const metricsKey = `${stablePsmKey}.${keyword}.metrics`;
   if (toSlotReviver.has(metricsKey)) {
     const metrics = toSlotReviver.getItem(metricsKey);
-    produceAnchorBalancePayments.resolve(makeScalarMapStore());
+    produceAnchorBalancePayments.resolve(
+      makeScalarBigMapStore('Anchor balance payments', { durable: true }),
+    );
     // XXX this rule should only apply to the 1st await
     // eslint-disable-next-line @jessie.js/no-nested-await
     const anchorPaymentMap = await anchorBalancePayments;
 
+    // TODO: validate that `metrics.anchorPoolBalance.value` is
+    // pass-by-copy PureData (e.g., contains no remotables).
     // eslint-disable-next-line @jessie.js/no-nested-await
     const pmt = await E(mint).mintPayment(
       AmountMath.make(brand, metrics.anchorPoolBalance.value),
@@ -423,6 +439,7 @@ export const PSM_MANIFEST = {
       agoricNamesAdmin: true,
       board: true,
       chainStorage: true,
+      diagnostics: true,
       zoe: 'zoe',
       feeMintAccess: 'zoe',
       economicCommitteeCreatorFacet: 'economicCommittee',

package/src/psm/psm.js

@@ -89,12 +89,17 @@ export const customTermsShape = {
 };
 harden(customTermsShape);
 
-export const privateArgsShape = {
-  feeMintAccess: FeeMintAccessShape,
-  initialPoserInvitation: InvitationShape,
-  storageNode: StorageNodeShape,
-  marshaller: M.remotable('marshaller'),
-};
+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);
 
 /**

package/src/reserve/assetReserveKit.js

@@ -134,7 +134,7 @@ export const prepareAssetReserveKit = async (
             totalFeeMinted: state.totalFeeMinted,
             totalFeeBurned: state.totalFeeBurned,
           });
-          state.metricsKit.recorder.write(metrics);
+          void state.metricsKit.recorder.write(metrics);
         },
       },
       governedApis: {