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

package/src/proposals/startPSM.js

@@ -1,45 +1,105 @@
-// @ts-check
+// @jessie-check
 
+import { makeMap } from 'jessie.js';
 import { AmountMath, AssetKind } from '@agoric/ertp';
 import { CONTRACT_ELECTORATE, ParamTypes } from '@agoric/governance';
-import { makeStorageNodeChild } from '@agoric/vats/src/lib-chainStorage.js';
+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,
+  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 { reserveThenDeposit, reserveThenGetNamePaths } from './utils.js';
+import { reserveThenGetNamePaths } from './utils.js';
+
+import {
+  inviteCommitteeMembers,
+  startEconCharter,
+  inviteToEconCharter,
+} from './committee-proposal.js';
+
+/** @typedef {import('@agoric/vats/src/core/lib-boot.js').BootstrapManifest} BootstrapManifest */
+/** @typedef {import('../psm/psm.js').MetricsNotification} MetricsNotification */
+/** @typedef {import('./econ-behaviors.js').EconomyBootstrapPowers} EconomyBootstrapPowers */
 
 const BASIS_POINTS = 10000n;
 const { details: X } = assert;
 
-const { values } = Object;
+export { inviteCommitteeMembers, startEconCharter, inviteToEconCharter };
+
+const stablePsmKey = `published.psm.${Stable.symbol}`;
 
 /**
- * @param {EconomyBootstrapPowers & WellKnownSpaces} powers
+ * @param {Array<[key: string, value: string]>} chainStorageEntries
+ * @param {string} keyword
+ * @param {{ minted: Brand<'nat'>, anchor: Brand<'nat'> }} brands
+ * @returns {{ metrics?: MetricsNotification, governance?: GovernanceSubscriptionState }}
+ */
+const findOldPSMState = (chainStorageEntries, keyword, brands) => {
+  // In this reviver, object references are revived as boardIDs
+  // from the pre-bulldozer board.
+  const toSlotReviver = makeHistoryReviver(
+    chainStorageEntries,
+    slotToBoardRemote,
+  );
+  if (!toSlotReviver.has(`${stablePsmKey}.${keyword}.metrics`)) {
+    return {};
+  }
+  const metricsWithOldBoardIDs = toSlotReviver.getItem(
+    `${stablePsmKey}.${keyword}.metrics`,
+  );
+  const oldIDtoNewBrand = makeMap([
+    [metricsWithOldBoardIDs.feePoolBalance.brand.getBoardId(), brands.minted],
+    [
+      metricsWithOldBoardIDs.anchorPoolBalance.brand.getBoardId(),
+      brands.anchor,
+    ],
+  ]);
+  // 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`),
+    governance: brandReviver.getItem(`${stablePsmKey}.${keyword}.governance`),
+  };
+};
+
+/**
+ * @param {EconomyBootstrapPowers & WellKnownSpaces & ChainStorageVatParams} powers
  * @param {object} [config]
  * @param {bigint} [config.WantMintedFeeBP]
  * @param {bigint} [config.GiveMintedFeeBP]
  * @param {bigint} [config.MINT_LIMIT]
  * @param {{ anchorOptions?: AnchorOptions } } [config.options]
- *
- * @typedef {import('./econ-behaviors.js').EconomyBootstrapPowers} EconomyBootstrapPowers
  */
 export const startPSM = async (
   {
+    vatParameters: { chainStorageEntries = [] },
     consume: {
       agoricNamesAdmin,
       board,
+      diagnostics,
       zoe,
       feeMintAccess: feeMintAccessP,
       economicCommitteeCreatorFacet,
-      psmCharterCreatorFacet,
+      econCharterKit,
       provisionPoolStartResult,
       chainStorage,
       chainTimerService,
-      psmFacets,
+      psmKit,
+      anchorBalancePayments: anchorBalancePaymentsP,
     },
+    produce: { psmKit: producepsmKit },
     installation: {
       consume: { contractGovernor, psm: psmInstall },
     },
@@ -88,6 +148,12 @@ export const startPSM = async (
   const mintLimit = AmountMath.make(minted, MINT_LIMIT);
   const anchorDecimalPlaces = anchorInfo.decimalPlaces || 1n;
   const mintedDecimalPlaces = mintedInfo.decimalPlaces || 1n;
+
+  const oldState = findOldPSMState(chainStorageEntries, keyword, {
+    minted,
+    anchor: anchorBrand,
+  });
+
   const terms = await deeplyFulfilledObject(
     harden({
       anchorBrand,
@@ -98,10 +164,6 @@ export const startPSM = async (
         minted,
       ),
       governedParams: {
-        [CONTRACT_ELECTORATE]: {
-          type: ParamTypes.INVITATION,
-          value: electorateInvitationAmount,
-        },
         WantMintedFee: {
           type: ParamTypes.RATIO,
           value: makeRatio(WantMintedFeeBP, minted, BASIS_POINTS),
@@ -111,21 +173,26 @@ export const startPSM = async (
           value: makeRatio(GiveMintedFeeBP, minted, BASIS_POINTS),
         },
         MintLimit: { type: ParamTypes.AMOUNT, value: mintLimit },
-      },
-      [CONTRACT_ELECTORATE]: {
-        type: ParamTypes.INVITATION,
-        value: electorateInvitationAmount,
+        // Override numeric config values from restored state.
+        ...oldState.governance?.current,
+        // Don't override the invitation amount;
+        // the electorate is re-constituted rather than restored.
+        [CONTRACT_ELECTORATE]: {
+          type: ParamTypes.INVITATION,
+          value: electorateInvitationAmount,
+        },
       },
     }),
   );
 
   const psmStorageNode = await makeStorageNodeChild(chainStorage, 'psm');
-  const storageNode = E(
+  const storageNode = await E(
     E(psmStorageNode).makeChildNode(Stable.symbol),
   ).makeChildNode(keyword);
 
   const marshaller = await E(board).getPublishingMarshaller();
 
+  const instanceKey = `psm-${Stable.symbol}-${keyword}`;
   const governorTerms = await deeplyFulfilledObject(
     harden({
       timer: chainTimerService,
@@ -133,22 +200,26 @@ export const startPSM = async (
       governed: {
         terms,
         issuerKeywordRecord: { [keyword]: anchorIssuer },
+        label: instanceKey,
       },
     }),
   );
+  const psmPrivateArgs = {
+    feeMintAccess,
+    initialPoserInvitation,
+    marshaller,
+    storageNode,
+  };
+  /** @type {GovernorStartedInstallationKit<typeof psmInstall>} */
   const governorFacets = await E(zoe).startInstance(
     contractGovernor,
     {},
     governorTerms,
     harden({
       economicCommitteeCreatorFacet,
-      governed: {
-        feeMintAccess,
-        initialPoserInvitation,
-        marshaller,
-        storageNode,
-      },
+      governed: psmPrivateArgs,
     }),
+    `${instanceKey}.governor`,
   );
 
   const [psm, psmCreatorFacet, psmAdminFacet] = await Promise.all([
@@ -156,36 +227,56 @@ 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 => {
+    const anchorBalancePayments = await anchorBalancePaymentsP;
+    const anchorPmt = anchorBalancePayments.get(anchorBrand);
+
+    const { anchorPoolBalance: _a, ...nonPaymentMetrics } = metrics;
+
+    const seat = E(zoe).offer(
+      E(psmCreatorFacet).makeRestoreMetricsInvitation(),
+      harden({ give: { Anchor: metrics.anchorPoolBalance } }),
+      harden({ Anchor: anchorPmt }),
+      harden(nonPaymentMetrics),
+    );
+    await E(seat).getPayouts();
+  };
+  await (oldState.metrics && restoreMetrics(oldState.metrics));
 
-  /** @typedef {import('./econ-behaviors.js').PSMFacets} PSMFacets */
-  /** @type {PSMFacets} */
-  const newPsmFacets = {
+  /** @type {import('./econ-behaviors.js').PSMKit} */
+  const newpsmKit = harden({
+    label: instanceKey,
     psm,
     psmGovernor: governorFacets.instance,
     psmCreatorFacet,
     psmAdminFacet,
     psmGovernorCreatorFacet: governorFacets.creatorFacet,
-  };
+  });
 
-  /** @type {MapStore<Brand,PSMFacets>} */
-  const psmFacetsMap = await psmFacets;
+  // Provide pattern with a promise.
+  producepsmKit.resolve(makeScalarBigMapStore('PSM Kits', { durable: true }));
 
-  psmFacetsMap.init(anchorBrand, newPsmFacets);
-  const instanceKey = `psm-${Stable.symbol}-${keyword}`;
+  /** @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');
 
   await Promise.all([
-    E(instanceAdmin).update(instanceKey, newPsmFacets.psm),
-    E(psmCharterCreatorFacet).addInstance(
+    E(instanceAdmin).update(instanceKey, newpsmKit.psm),
+    E(E.get(econCharterKit).creatorFacet).addInstance(
       psm,
       governorFacets.creatorFacet,
-      anchorBrand,
-      minted,
+      instanceKey,
     ),
     // @ts-expect-error TODO type for provisionPoolStartResult
     E(E.get(provisionPoolStartResult).creatorFacet).initPSM(
       anchorBrand,
-      newPsmFacets.psm,
+      newpsmKit.psm,
     ),
   ]);
 };
@@ -203,16 +294,30 @@ harden(startPSM);
  * Make anchor issuer out of a Cosmos asset; presumably
  * USDC over IBC. Add it to BankManager.
  *
- * @param {EconomyBootstrapPowers & WellKnownSpaces} powers
+ * Also, if vatParameters shows an anchorPoolBalance for this asset,
+ * mint a payment for that balance.
+ *
+ * TODO: address redundancy with publishInterchainAssetFromBank
+ *
+ * @param {EconomyBootstrapPowers & WellKnownSpaces & ChainStorageVatParams} powers
  * @param {{options?: { anchorOptions?: AnchorOptions } }} [config]
  */
 export const makeAnchorAsset = async (
   {
-    consume: { agoricNamesAdmin, bankManager, zoe },
+    vatParameters: { chainStorageEntries = [] },
+    consume: {
+      agoricNamesAdmin,
+      bankManager,
+      startUpgradable,
+      anchorBalancePayments,
+    },
     installation: {
       consume: { mintHolder },
     },
-    produce: { testFirstAnchorKit },
+    produce: {
+      testFirstAnchorKit,
+      anchorBalancePayments: produceAnchorBalancePayments,
+    },
   },
   { options: { anchorOptions = {} } = {} },
 ) => {
@@ -239,17 +344,44 @@ export const makeAnchorAsset = async (
       },
     }),
   );
-  const { creatorFacet: mint, publicFacet: issuerP } = E.get(
-    E(zoe).startInstance(mintHolder, {}, terms),
-  );
-  const issuer = await issuerP; // identity of issuers is important
+
+  /** @type {{ creatorFacet: ERef<Mint<'nat'>>, publicFacet: ERef<Issuer<'nat'>> }} */
+  // @ts-expect-error cast
+  const { creatorFacet: mint, publicFacet: issuer } = await E(startUpgradable)({
+    installation: mintHolder,
+    label: keyword,
+    terms,
+  });
 
   const brand = await E(issuer).getBrand();
-  const kit = { mint, issuer, brand };
+  const kit = harden({ mint, issuer, brand });
 
   testFirstAnchorKit.resolve(kit);
 
-  return Promise.all([
+  const toSlotReviver = makeHistoryReviver(
+    chainStorageEntries,
+    slotToBoardRemote,
+  );
+  const metricsKey = `${stablePsmKey}.${keyword}.metrics`;
+  if (toSlotReviver.has(metricsKey)) {
+    const metrics = toSlotReviver.getItem(metricsKey);
+    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),
+    );
+    anchorPaymentMap.init(brand, pmt);
+  }
+
+  await Promise.all([
     E(E(agoricNamesAdmin).lookupAdmin('issuer')).update(keyword, kit.issuer),
     E(E(agoricNamesAdmin).lookupAdmin('brand')).update(keyword, kit.brand),
     E(bankManager).addAsset(
@@ -264,185 +396,60 @@ harden(makeAnchorAsset);
 
 /** @typedef {import('./econ-behaviors.js').EconomyBootstrapSpace} EconomyBootstrapSpace */
 
-/** @param {BootstrapSpace & EconomyBootstrapSpace & { devices: { vatAdmin: any }, vatPowers: { D: DProxy }, }} powers */
-export const installGovAndPSMContracts = async ({
-  vatPowers: { D },
-  devices: { vatAdmin },
-  consume: { zoe },
-  produce: { psmFacets },
-  installation: {
-    produce: {
-      contractGovernor,
-      committee,
-      binaryVoteCounter,
-      psm,
-      psmCharter,
-    },
-  },
-}) => {
-  // In order to support multiple instances of the PSM, we store all the facets
-  // indexed by the brand. Since each name in the BootstrapSpace can only be
-  // produced  once, we produce an empty store here, and each time a PSM is
-  // started up, the details are added to the store.
-  psmFacets.resolve(makeScalarMapStore());
-
-  return Promise.all(
-    Object.entries({
-      contractGovernor,
-      committee,
-      binaryVoteCounter,
-      psm,
-      psmCharter,
-    }).map(async ([name, producer]) => {
-      const bundleCap = D(vatAdmin).getNamedBundleCap(name);
-      const bundle = D(bundleCap).getBundle();
-      const installation = E(zoe).install(bundle);
-
-      producer.resolve(installation);
-    }),
-  );
-};
-
-/** @param {EconomyBootstrapPowers} powers */
-export const startPSMCharter = async ({
-  consume: { zoe },
-  produce: { psmCharterCreatorFacet, psmCharterAdminFacet },
-  installation: {
-    consume: { binaryVoteCounter, psmCharter: installP },
-  },
-  instance: {
-    produce: { psmCharter: instanceP },
-  },
-}) => {
-  const [charterR, counterR] = await Promise.all([installP, binaryVoteCounter]);
-
-  const terms = { binaryVoteCounterInstallation: counterR };
-  const facets = await E(zoe).startInstance(charterR, {}, terms);
-
-  instanceP.resolve(facets.instance);
-  psmCharterCreatorFacet.resolve(facets.creatorFacet);
-  psmCharterAdminFacet.resolve(facets.adminFacet);
-};
-
-/**
- * PSM and gov contracts are available as
- * named swingset bundles only in
- * decentral-psm-config.json
- */
-export const PSM_GOV_MANIFEST = {
-  [installGovAndPSMContracts.name]: {
-    vatPowers: { D: true },
-    devices: { vatAdmin: true },
-    consume: { zoe: 'zoe' },
-    produce: { psmFacets: 'true' },
-    installation: {
-      produce: {
-        contractGovernor: 'zoe',
-        committee: 'zoe',
-        binaryVoteCounter: 'zoe',
-        psm: 'zoe',
-        psmCharter: 'zoe',
+export const INVITE_PSM_COMMITTEE_MANIFEST = harden(
+  /** @type {BootstrapManifest} */ ({
+    [inviteCommitteeMembers.name]: {
+      consume: {
+        namesByAddressAdmin: true,
+        economicCommitteeCreatorFacet: true,
+        econCharterKit: true,
+        highPrioritySendersManager: true,
       },
     },
-  },
-  [startPSMCharter.name]: {
-    consume: { zoe: 'zoe' },
-    produce: {
-      psmCharterCreatorFacet: 'psmCharter',
-      psmCharterAdminFacet: 'psmCharter',
-    },
-    installation: {
-      consume: { binaryVoteCounter: 'zoe', psmCharter: 'zoe' },
-    },
-    instance: {
-      produce: { psmCharter: 'psmCharter' },
-    },
-  },
-};
-
-/** @type { <X, Y>(xs: X[], ys: Y[]) => [X, Y][]} */
-const zip = (xs, ys) => xs.map((x, i) => [x, ys[i]]);
-
-/**
- * @param {import('./econ-behaviors').EconomyBootstrapPowers} powers
- * @param {{ options: { voterAddresses: Record<string, string> }}} param1
- */
-export const invitePSMCommitteeMembers = async (
-  {
-    consume: {
-      namesByAddressAdmin,
-      economicCommitteeCreatorFacet,
-      psmCharterCreatorFacet,
+    [inviteToEconCharter.name]: {
+      consume: {
+        namesByAddressAdmin: true,
+        econCharterKit: true,
+      },
     },
-  },
-  { options: { voterAddresses = {} } },
-) => {
-  const invitations = await E(
-    economicCommitteeCreatorFacet,
-  ).getVoterInvitations();
-  assert.equal(invitations.length, values(voterAddresses).length);
-
-  /**
-   * @param {[string, Promise<Invitation>][]} addrInvitations
-   */
-  const distributeInvitations = async addrInvitations => {
-    await Promise.all(
-      addrInvitations.map(async ([addr, invitationP]) => {
-        const [voterInvitation, charterMemberInvitation] = await Promise.all([
-          invitationP,
-          E(psmCharterCreatorFacet).makeCharterMemberInvitation(),
-        ]);
-        console.log('sending charter, voting invitations to', addr);
-        await reserveThenDeposit(
-          `econ committee member ${addr}`,
-          namesByAddressAdmin,
-          addr,
-          [voterInvitation, charterMemberInvitation],
-        );
-        console.log('sent charter, voting invitations to', addr);
-      }),
-    );
-  };
-
-  await distributeInvitations(zip(values(voterAddresses), invitations));
-};
-harden(invitePSMCommitteeMembers);
+  }),
+);
 
-export const INVITE_PSM_COMMITTEE_MANIFEST = harden({
-  [invitePSMCommitteeMembers.name]: {
+/** @type {BootstrapManifest} */
+export const PSM_MANIFEST = {
+  [makeAnchorAsset.name]: {
+    vatParameters: { chainStorageEntries: true },
     consume: {
-      namesByAddressAdmin: true,
-      economicCommitteeCreatorFacet: true,
-      psmCharterCreatorFacet: true,
+      agoricNamesAdmin: true,
+      bankManager: 'bank',
+      startUpgradable: true,
+      anchorBalancePayments: true,
+      anchorKits: true,
     },
-  },
-});
-
-export const PSM_MANIFEST = harden({
-  [makeAnchorAsset.name]: {
-    consume: { agoricNamesAdmin: true, bankManager: 'bank', zoe: 'zoe' },
     installation: { consume: { mintHolder: 'zoe' } },
-    issuer: {
-      produce: { AUSD: true },
-    },
-    brand: {
-      produce: { AUSD: true },
+    produce: {
+      testFirstAnchorKit: true,
+      anchorBalancePayments: true,
+      anchorKits: true,
     },
-    produce: { testFirstAnchorKit: true },
   },
   [startPSM.name]: {
+    vatParameters: { chainStorageEntries: true },
     consume: {
       agoricNamesAdmin: true,
       board: true,
       chainStorage: true,
+      diagnostics: true,
       zoe: 'zoe',
       feeMintAccess: 'zoe',
       economicCommitteeCreatorFacet: 'economicCommittee',
       provisionPoolStartResult: true,
-      psmCharterCreatorFacet: 'psmCharter',
+      econCharterKit: 'econCommitteeCharter',
       chainTimerService: 'timer',
-      psmFacets: true,
+      psmKit: true,
+      anchorBalancePayments: true,
     },
+    produce: { psmKit: 'true' },
     installation: {
       consume: { contractGovernor: 'zoe', psm: 'zoe' },
     },
@@ -450,13 +457,26 @@ export const PSM_MANIFEST = harden({
       consume: { economicCommittee: 'economicCommittee' },
     },
     brand: {
-      consume: { AUSD: 'bank', IST: 'zoe' },
-    },
-    issuer: {
-      consume: { AUSD: 'bank' },
+      consume: { [Stable.symbol]: 'zoe' },
     },
   },
-});
+};
+harden(PSM_MANIFEST);
+
+export const getManifestForPsmGovernance = (
+  { restoreRef },
+  { installKeys },
+) => {
+  return {
+    manifest: {},
+    installations: {
+      econCommitteeCharter: restoreRef(installKeys.econCommitteeCharter),
+      contractGovernor: restoreRef(installKeys.contractGovernor),
+      committee: restoreRef(installKeys.committee),
+      binaryVoteCounter: restoreRef(installKeys.binaryVoteCounter),
+    },
+  };
+};
 
 export const getManifestForPsm = (
   { restoreRef },