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

package/src/proposals/core-proposal.js

@@ -1,88 +1,89 @@
-// @ts-check
+// @jessie-check
+
 import { Stable } from '@agoric/vats/src/tokens.js';
 import * as econBehaviors from './econ-behaviors.js';
 import { ECON_COMMITTEE_MANIFEST } from './startEconCommittee.js';
-import * as simBehaviors from './sim-behaviors.js';
 
 export * from './econ-behaviors.js';
-export * from './sim-behaviors.js';
 // @ts-expect-error Module './econ-behaviors.js' has already exported a member
 // named 'EconomyBootstrapPowers'.
-export * from './startPSM.js';
-export * from './startEconCommittee.js';
+export * from './startPSM.js'; // eslint-disable-line import/export
+export * from './startEconCommittee.js'; // eslint-disable-line import/export
 
-const SHARED_MAIN_MANIFEST = harden({
-  [econBehaviors.setupAmm.name]: {
-    consume: {
-      board: 'board',
-      chainStorage: true,
-      chainTimerService: 'timer',
-      zoe: 'zoe',
-      economicCommitteeCreatorFacet: 'economicCommittee',
-    },
-    produce: {
-      ammCreatorFacet: 'amm',
-      ammInstanceWithoutReserve: 'amm',
-      ammGovernorCreatorFacet: 'amm',
-    },
-    issuer: { consume: { [Stable.symbol]: 'zoe' } },
-    brand: { consume: { [Stable.symbol]: 'zoe' } },
-    installation: {
-      consume: { contractGovernor: 'zoe', amm: 'zoe' },
-    },
-    instance: {
-      produce: { ammGovernor: 'ammGovernor' },
-    },
-  },
-  [econBehaviors.startInterchainPool.name]: {
-    consume: { bankManager: 'bank', zoe: 'zoe', agoricNamesAdmin: true },
-    installation: {
-      consume: { interchainPool: 'zoe' },
-    },
-    brand: {
-      consume: { [Stable.symbol]: 'zoe' },
-    },
-    issuer: {
-      consume: { [Stable.symbol]: 'zoe' },
-    },
-    instance: {
-      consume: { amm: 'amm' },
-      produce: { interchainPool: 'interchainPool' },
-    },
+// 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} */
   [econBehaviors.startVaultFactory.name]: {
     consume: {
       board: 'board',
       chainStorage: true,
+      diagnostics: true,
       feeMintAccess: 'zoe',
       chainTimerService: 'timer',
       zoe: 'zoe',
       priceAuthority: 'priceAuthority',
       economicCommitteeCreatorFacet: 'economicCommittee',
-      reserveCreatorFacet: 'reserve',
-    },
-    produce: {
-      vaultFactoryCreator: 'VaultFactory',
-      vaultFactoryGovernorCreator: 'VaultFactory',
-      vaultFactoryVoteCreator: 'VaultFactory',
+      reserveKit: 'reserve',
+      auctioneerKit: 'auction',
     },
+    produce: { vaultFactoryKit: 'VaultFactory' },
     brand: { consume: { [Stable.symbol]: 'zoe' } },
     oracleBrand: { consume: { USD: true } },
     installation: {
       consume: {
         contractGovernor: 'zoe',
         VaultFactory: 'zoe',
-        liquidate: 'zoe',
       },
     },
     instance: {
       consume: {
-        amm: 'amm',
         reserve: 'reserve',
+        auctioneer: 'auction',
       },
       produce: {
         VaultFactory: 'VaultFactory',
-        Treasury: 'VaultFactory',
         VaultFactoryGovernor: 'VaultFactoryGovernor',
       },
     },
@@ -91,61 +92,67 @@ const SHARED_MAIN_MANIFEST = harden({
     consume: {
       client: 'provisioning',
       priceAuthorityAdmin: 'priceAuthority',
-      vaultFactoryCreator: 'VaultFactory',
+      vaultFactoryKit: 'VaultFactory',
     },
   },
 
   [econBehaviors.setupReserve.name]: {
     consume: {
-      ammCreatorFacet: 'amm',
-      ammInstanceWithoutReserve: 'amm',
       board: 'board',
       chainStorage: true,
+      diagnostics: true,
       feeMintAccess: 'zoe',
       chainTimerService: 'timer',
       zoe: 'zoe',
       economicCommitteeCreatorFacet: 'economicCommittee',
     },
-    produce: {
-      reserveCreatorFacet: 'reserve',
-      reserveGovernorCreatorFacet: 'reserve',
-      reservePublicFacet: 'reserve',
-    },
+    produce: { reserveKit: 'reserve' },
     issuer: { consume: { [Stable.symbol]: 'zoe' } },
     brand: { consume: { [Stable.symbol]: 'zoe' } },
     installation: {
       consume: { contractGovernor: 'zoe', reserve: 'zoe' },
     },
     instance: {
-      consume: { amm: 'amm' },
       produce: {
-        amm: 'amm',
         reserve: 'reserve',
         reserveGovernor: 'ReserveGovernor',
       },
     },
   },
 
-  [econBehaviors.configureVaultFactoryUI.name]: {
+  [econBehaviors.startAuctioneer.name]: {
     consume: {
-      board: true,
-      zoe: true,
+      zoe: 'zoe',
+      board: 'board',
+      chainTimerService: 'timer',
+      priceAuthority: 'priceAuthority',
+      chainStorage: true,
+      economicCommitteeCreatorFacet: 'economicCommittee',
+    },
+    produce: { auctioneerKit: 'auction' },
+    instance: {
+      produce: { auctioneer: 'auction' },
+      consume: { reserve: 'auction' },
     },
-    issuer: { consume: { [Stable.symbol]: 'zoe' } },
-    brand: { consume: { [Stable.symbol]: 'zoe' } },
     installation: {
-      consume: {
-        amm: 'zoe',
-        VaultFactory: 'zoe',
-        contractGovernor: 'zoe',
-        binaryVoteCounter: 'zoe',
-        liquidate: 'zoe',
-      },
+      consume: { contractGovernor: 'zoe', auctioneer: 'zoe' },
     },
-    instance: {
-      consume: { amm: 'amm', VaultFactory: 'VaultFactory' },
+    issuer: {
+      consume: { [Stable.symbol]: 'zoe' },
+    },
+  },
+
+  [storeInterContractStartKits.name]: {
+    consume: {
+      contractKits: true,
+      governedContractKits: true,
+      econCharterKit: true,
+      economicCommitteeKit: true,
+      feeDistributorKit: true,
+      auctioneerKit: true,
+      reserveKit: true,
+      vaultFactoryKit: true,
     },
-    uiConfig: { produce: { Treasury: true, VaultFactory: true } },
   },
 });
 
@@ -153,15 +160,14 @@ const REWARD_MANIFEST = harden({
   [econBehaviors.startRewardDistributor.name]: {
     consume: {
       chainTimerService: true,
+      diagnostics: true,
       bankManager: true,
-      vaultFactoryCreator: true,
+      vaultFactoryKit: true,
       periodicFeeCollectors: true,
-      ammCreatorFacet: true,
-      stakeFactoryCreatorFacet: true,
-      reservePublicFacet: true,
+      reserveKit: true,
       zoe: true,
     },
-    produce: { feeDistributorCreatorFacet: true, periodicFeeCollectors: true },
+    produce: { feeDistributorKit: true, periodicFeeCollectors: true },
     instance: { produce: { feeDistributor: true } },
     installation: { consume: { feeDistributor: true } },
     issuer: { consume: { [Stable.symbol]: 'zoe' } },
@@ -169,75 +175,7 @@ const REWARD_MANIFEST = harden({
   },
 });
 
-const STAKE_FACTORY_MANIFEST = harden({
-  [econBehaviors.startLienBridge.name]: {
-    consume: { bridgeManager: true },
-    produce: { lienBridge: true },
-    brand: {
-      consume: { BLD: 'BLD' },
-    },
-  },
-  [econBehaviors.startStakeFactory.name]: {
-    consume: {
-      board: 'board',
-      chainStorage: true,
-      zoe: 'zoe',
-      feeMintAccess: 'zoe',
-      lienBridge: true,
-      client: 'provisioning',
-      chainTimerService: 'timer',
-      economicCommitteeCreatorFacet: 'economicCommittee',
-    },
-    produce: {
-      stakeFactoryCreatorFacet: 'stakeFactory',
-      stakeFactoryGovernorCreatorFacet: 'stakeFactory',
-    },
-    installation: {
-      consume: { contractGovernor: 'zoe', stakeFactory: 'zoe' },
-    },
-    instance: {
-      produce: { stakeFactory: 'stakeFactory' },
-    },
-    brand: {
-      consume: { BLD: 'BLD', [Stable.symbol]: 'zoe' },
-      produce: { Attestation: 'stakeFactory' },
-    },
-    issuer: {
-      consume: { BLD: 'BLD' },
-      produce: { Attestation: 'stakeFactory' },
-    },
-  },
-});
-
-export const SIM_CHAIN_MANIFEST = harden({
-  [simBehaviors.fundAMM.name]: {
-    consume: {
-      centralSupplyBundle: true,
-      mintHolderBundle: true,
-      chainTimerService: 'timer',
-      bldIssuerKit: true,
-      feeMintAccess: true,
-      loadVat: true,
-      mints: 'mints',
-      priceAuthorityVat: 'priceAuthority',
-      priceAuthorityAdmin: 'priceAuthority',
-      vaultFactoryCreator: 'VaultFactory',
-      zoe: true,
-    },
-    installation: {
-      consume: { centralSupply: 'zoe' },
-    },
-    issuer: {
-      consume: { [Stable.symbol]: 'zoe' },
-    },
-    brand: {
-      consume: { [Stable.symbol]: 'zoe' },
-    },
-    instance: {
-      consume: { amm: 'amm' },
-    },
-  },
-});
+export const SIM_CHAIN_MANIFEST = harden({});
 
 export const getManifestForEconCommittee = (
   { restoreRef },
@@ -258,42 +196,37 @@ export const getManifestForEconCommittee = (
 
 export const getManifestForMain = (
   { restoreRef },
-  { installKeys, vaultFactoryControllerAddress, minInitialPoolLiquidity },
+  {
+    installKeys,
+    vaultFactoryControllerAddress,
+    minInitialPoolLiquidity,
+    endorsedUi,
+  },
 ) => {
   return {
     manifest: SHARED_MAIN_MANIFEST,
     installations: {
-      amm: restoreRef(installKeys.amm),
       VaultFactory: restoreRef(installKeys.vaultFactory),
+      auctioneer: restoreRef(installKeys.auctioneer),
       feeDistributor: restoreRef(installKeys.feeDistributor),
-      liquidate: restoreRef(installKeys.liquidate),
       reserve: restoreRef(installKeys.reserve),
-      interchainPool: restoreRef(installKeys.interchainPool),
     },
     options: {
       vaultFactoryControllerAddress,
       minInitialPoolLiquidity,
+      endorsedUi,
     },
   };
 };
 
-const roleToManifest = harden({
-  chain: {
-    ...REWARD_MANIFEST,
-    ...STAKE_FACTORY_MANIFEST,
-  },
-  'sim-chain': SIM_CHAIN_MANIFEST,
-  client: {},
-});
-
 export const getManifestForInterProtocol = (
   { restoreRef },
   {
-    ROLE = 'chain',
     econCommitteeOptions,
     installKeys,
     vaultFactoryControllerAddress,
     minInitialPoolLiquidity,
+    endorsedUi,
   },
 ) => {
   const econCommitteeManifest = getManifestForEconCommittee(
@@ -306,18 +239,18 @@ export const getManifestForInterProtocol = (
       installKeys,
       vaultFactoryControllerAddress,
       minInitialPoolLiquidity,
+      endorsedUi,
     },
   );
   return {
     manifest: {
       ...econCommitteeManifest.manifest,
       ...mainManifest.manifest,
-      ...roleToManifest[ROLE],
+      ...REWARD_MANIFEST,
     },
     installations: {
       ...econCommitteeManifest.installations,
       ...mainManifest.installations,
-      stakeFactory: restoreRef(installKeys.stakeFactory),
     },
     options: {
       ...econCommitteeManifest.options,