@agoric/inter-protocol 0.13.2-dev-65d3f14.0 → 0.13.2-pismo-dev-12e97f1.0

package/src/proposals/sim-behaviors.js

@@ -1,3 +1,4 @@
+// @ts-check
 import { E, Far } from '@endo/far';
 import { addRemote } from '@agoric/vats/src/core/utils.js';
 

package/src/proposals/startEconCommittee.js

@@ -1,3 +1,4 @@
+// @ts-check
 import {
   assertPathSegment,
   makeStorageNodeChild,
@@ -5,7 +6,7 @@ import {
 import { E } from '@endo/far';
 import { makeTracer } from '../makeTracer.js';
 
-const trace = makeTracer('RunEconCommittee', false);
+const trace = makeTracer('RunEconBehaviors', false);
 
 /** @type {(name: string) => string} */
 const sanitizePathSegment = name => {

package/src/proposals/startPSM.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import { AmountMath, AssetKind } from '@agoric/ertp';
 import { CONTRACT_ELECTORATE, ParamTypes } from '@agoric/governance';
 import { makeStorageNodeChild } from '@agoric/vats/src/lib-chainStorage.js';
@@ -7,18 +9,12 @@ import { Stable } from '@agoric/vats/src/tokens.js';
 import { deeplyFulfilledObject } from '@agoric/internal';
 import { makeScalarMapStore } from '@agoric/vat-data';
 
-import { reserveThenGetNamePaths } from './utils.js';
-
-import {
-  inviteCommitteeMembers,
-  startEconCharter,
-  inviteToEconCharter,
-} from './committee-proposal.js';
+import { reserveThenDeposit, reserveThenGetNamePaths } from './utils.js';
 
 const BASIS_POINTS = 10000n;
 const { details: X } = assert;
 
-export { inviteCommitteeMembers, startEconCharter, inviteToEconCharter };
+const { values } = Object;
 
 /**
  * @param {EconomyBootstrapPowers & WellKnownSpaces} powers
@@ -38,13 +34,12 @@ export const startPSM = async (
       zoe,
       feeMintAccess: feeMintAccessP,
       economicCommitteeCreatorFacet,
-      econCharterKit,
+      psmCharterCreatorFacet,
       provisionPoolStartResult,
       chainStorage,
       chainTimerService,
-      psmKit,
+      psmFacets,
     },
-    produce: { psmKit: producepsmKit },
     installation: {
       consume: { contractGovernor, psm: psmInstall },
     },
@@ -162,9 +157,9 @@ export const startPSM = async (
     E(governorFacets.creatorFacet).getAdminFacet(),
   ]);
 
-  /** @typedef {import('./econ-behaviors.js').PSMKit} psmKit */
-  /** @type {psmKit} */
-  const newpsmKit = {
+  /** @typedef {import('./econ-behaviors.js').PSMFacets} PSMFacets */
+  /** @type {PSMFacets} */
+  const newPsmFacets = {
     psm,
     psmGovernor: governorFacets.instance,
     psmCreatorFacet,
@@ -172,27 +167,25 @@ export const startPSM = async (
     psmGovernorCreatorFacet: governorFacets.creatorFacet,
   };
 
-  // Provide pattern with a promise.
-  producepsmKit.resolve(makeScalarMapStore());
-
-  /** @type {MapStore<Brand,psmKit>} */
-  const psmKitMap = await psmKit;
+  /** @type {MapStore<Brand,PSMFacets>} */
+  const psmFacetsMap = await psmFacets;
 
-  psmKitMap.init(anchorBrand, newpsmKit);
+  psmFacetsMap.init(anchorBrand, newPsmFacets);
   const instanceKey = `psm-${Stable.symbol}-${keyword}`;
   const instanceAdmin = E(agoricNamesAdmin).lookupAdmin('instance');
 
   await Promise.all([
-    E(instanceAdmin).update(instanceKey, newpsmKit.psm),
-    E(E.get(econCharterKit).creatorFacet).addInstance(
+    E(instanceAdmin).update(instanceKey, newPsmFacets.psm),
+    E(psmCharterCreatorFacet).addInstance(
       psm,
       governorFacets.creatorFacet,
-      instanceKey,
+      anchorBrand,
+      minted,
     ),
     // @ts-expect-error TODO type for provisionPoolStartResult
     E(E.get(provisionPoolStartResult).creatorFacet).initPSM(
       anchorBrand,
-      newpsmKit.psm,
+      newPsmFacets.psm,
     ),
   ]);
 };
@@ -246,8 +239,6 @@ export const makeAnchorAsset = async (
       },
     }),
   );
-  /** @type {{ creatorFacet: ERef<Mint<'nat'>>, publicFacet: ERef<Issuer<'nat'>> }} */
-  // @ts-expect-error cast
   const { creatorFacet: mint, publicFacet: issuerP } = E.get(
     E(zoe).startInstance(mintHolder, {}, terms),
   );
@@ -278,14 +269,14 @@ export const installGovAndPSMContracts = async ({
   vatPowers: { D },
   devices: { vatAdmin },
   consume: { zoe },
-  produce: { psmKit },
+  produce: { psmFacets },
   installation: {
     produce: {
       contractGovernor,
       committee,
       binaryVoteCounter,
       psm,
-      econCommitteeCharter,
+      psmCharter,
     },
   },
 }) => {
@@ -293,7 +284,7 @@ export const installGovAndPSMContracts = async ({
   // 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.
-  psmKit.resolve(makeScalarMapStore());
+  psmFacets.resolve(makeScalarMapStore());
 
   return Promise.all(
     Object.entries({
@@ -301,7 +292,7 @@ export const installGovAndPSMContracts = async ({
       committee,
       binaryVoteCounter,
       psm,
-      econCommitteeCharter,
+      psmCharter,
     }).map(async ([name, producer]) => {
       const bundleCap = D(vatAdmin).getNamedBundleCap(name);
       const bundle = D(bundleCap).getBundle();
@@ -312,68 +303,131 @@ export const installGovAndPSMContracts = async ({
   );
 };
 
+/** @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
- *
- * @type {import('@agoric/vats/src/core/manifest.js').BootstrapManifest}
  */
 export const PSM_GOV_MANIFEST = {
   [installGovAndPSMContracts.name]: {
     vatPowers: { D: true },
     devices: { vatAdmin: true },
     consume: { zoe: 'zoe' },
-    produce: { psmKit: 'true' },
+    produce: { psmFacets: 'true' },
     installation: {
       produce: {
         contractGovernor: 'zoe',
         committee: 'zoe',
         binaryVoteCounter: 'zoe',
         psm: 'zoe',
-        econCommitteeCharter: 'zoe',
+        psmCharter: 'zoe',
       },
     },
   },
-  [startEconCharter.name]: {
-    consume: { zoe: 'zoe', agoricNames: true },
+  [startPSMCharter.name]: {
+    consume: { zoe: 'zoe' },
     produce: {
-      econCharterKit: 'econCommitteeCharter',
+      psmCharterCreatorFacet: 'psmCharter',
+      psmCharterAdminFacet: 'psmCharter',
     },
     installation: {
-      consume: { binaryVoteCounter: 'zoe', econCommitteeCharter: 'zoe' },
+      consume: { binaryVoteCounter: 'zoe', psmCharter: 'zoe' },
     },
     instance: {
-      produce: { econCommitteeCharter: 'econCommitteeCharter' },
+      produce: { psmCharter: 'psmCharter' },
     },
   },
 };
 
-export const INVITE_PSM_COMMITTEE_MANIFEST = harden(
-  /** @type {import('@agoric/vats/src/core/manifest.js').BootstrapManifest} */
-  ({
-    [inviteCommitteeMembers.name]: {
-      consume: {
-        namesByAddressAdmin: true,
-        economicCommitteeCreatorFacet: true,
-        econCharterKit: true,
-      },
+/** @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]: {
+    consume: {
+      namesByAddressAdmin: true,
+      economicCommitteeCreatorFacet: true,
+      psmCharterCreatorFacet: true,
     },
-  }),
-);
+  },
+});
 
-/** @type {import('@agoric/vats/src/core/manifest.js').BootstrapManifest} */
 export const PSM_MANIFEST = harden({
-  /** @type {import('@agoric/vats/src/core/manifest.js').BootstrapManifestPermit} */
   [makeAnchorAsset.name]: {
     consume: { agoricNamesAdmin: true, bankManager: 'bank', zoe: 'zoe' },
     installation: { consume: { mintHolder: 'zoe' } },
+    issuer: {
+      produce: { AUSD: true },
+    },
+    brand: {
+      produce: { AUSD: true },
+    },
     produce: { testFirstAnchorKit: true },
   },
   [startPSM.name]: {
@@ -385,11 +439,10 @@ export const PSM_MANIFEST = harden({
       feeMintAccess: 'zoe',
       economicCommitteeCreatorFacet: 'economicCommittee',
       provisionPoolStartResult: true,
-      econCharterKit: 'econCommitteeCharter',
+      psmCharterCreatorFacet: 'psmCharter',
       chainTimerService: 'timer',
-      psmKit: true,
+      psmFacets: true,
     },
-    produce: { psmKit: 'true' },
     installation: {
       consume: { contractGovernor: 'zoe', psm: 'zoe' },
     },
@@ -397,27 +450,14 @@ export const PSM_MANIFEST = harden({
       consume: { economicCommittee: 'economicCommittee' },
     },
     brand: {
-      consume: { [Stable.symbol]: 'zoe' },
+      consume: { AUSD: 'bank', IST: 'zoe' },
+    },
+    issuer: {
+      consume: { AUSD: 'bank' },
     },
   },
 });
 
-export const getManifestForPsmGovernance = (
-  { restoreRef },
-  { installKeys },
-) => {
-  const { [installGovAndPSMContracts.name]: _, ...manifest } = PSM_GOV_MANIFEST;
-  return {
-    manifest,
-    installations: {
-      econCommitteeCharter: restoreRef(installKeys.econCommitteeCharter),
-      contractGovernor: restoreRef(installKeys.contractGovernor),
-      committee: restoreRef(installKeys.committee),
-      binaryVoteCounter: restoreRef(installKeys.binaryVoteCounter),
-    },
-  };
-};
-
 export const getManifestForPsm = (
   { restoreRef },
   { installKeys, anchorOptions },

package/src/proposals/utils.js

@@ -4,16 +4,16 @@ import { E } from '@endo/far';
 // must match packages/wallet/api/src/lib-wallet.js
 export const DEPOSIT_FACET = 'depositFacet';
 
-const { Fail } = assert;
+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) => {
@@ -36,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) =>
@@ -58,24 +58,16 @@ export const reserveThenDeposit = async (
   addr,
   payments,
 ) => {
-  console.info('awaiting depositFacet for', debugName);
+  console.info('waiting for', debugName);
   const [depositFacet] = await reserveThenGetNamePaths(namesByAddressAdmin, [
     [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/solo/src/scratch').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) {
@@ -88,7 +80,7 @@ const provideWhen = async (store, key, make) => {
 
 /**
  *
- * @param {{ scratch: ERef<import('@agoric/solo/src/scratch').ScratchPad> }} homeP
+ * @param {{ scratch: ERef<MapStore<string, unknown>> }} homeP
  * @param {object} opts
  * @param {(specifier: string) => Promise<{default: Bundle}>} opts.loadBundle
  * @param {string} [opts.installCacheKey]
@@ -116,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,13 +1,13 @@
+// @ts-check
 import '@agoric/zoe/exported.js';
 import '@agoric/zoe/src/contracts/exported.js';
-import '@agoric/governance/exported.js';
+import '@agoric/governance/src/exported.js';
 
 import { E } from '@endo/eventual-send';
 import {
   ceilMultiplyBy,
   floorDivideBy,
   floorMultiplyBy,
-  atomicRearrange,
 } from '@agoric/zoe/src/contractSupport/index.js';
 import { Far } from '@endo/marshal';
 import {
@@ -21,7 +21,7 @@ import { AmountMath } from '@agoric/ertp';
 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
@@ -39,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
  *
@@ -50,6 +48,21 @@ const { Fail } = assert;
  * ever given by this contract
  */
 
+/**
+ * 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);
+};
+
 /** @typedef {import('@agoric/vat-data').Baggage} Baggage */
 
 /**
@@ -58,7 +71,7 @@ const { Fail } = assert;
  *    WantMintedFee: 'ratio',
  *    MintLimit: 'amount',
  *   }> & {
- *    anchorBrand: Brand<'nat'>,
+ *    anchorBrand: Brand,
  *    anchorPerMinted: Ratio,
  * }>} zcf
  * @param {{feeMintAccess: FeeMintAccess, initialPoserInvitation: Invitation, storageNode: StorageNode, marshaller: Marshaller}} privateArgs
@@ -73,9 +86,11 @@ export const start = async (zcf, privateArgs, baggage) => {
     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(),
@@ -139,7 +154,7 @@ export const start = async (zcf, privateArgs, baggage) => {
   const assertUnderLimit = 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 => {
@@ -162,19 +177,25 @@ export const start = 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);
+      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);
   };
 
@@ -189,21 +210,18 @@ export const start = 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;
     }
@@ -257,7 +275,7 @@ export const start = async (zcf, privateArgs, baggage) => {
         wantmintedHook,
         'wantMinted',
         undefined,
-        M.splitRecord({
+        M.split({
           give: { In: anchorAmountShape },
           want: M.or({ Out: stableAmountShape }, {}),
         }),
@@ -268,7 +286,7 @@ export const start = async (zcf, privateArgs, baggage) => {
         giveMintedHook,
         'giveMinted',
         undefined,
-        M.splitRecord({
+        M.split({
           give: { In: stableAmountShape },
           want: M.or({ Out: anchorAmountShape }, {}),
         }),