@agoric/inter-protocol 0.13.2-dev-0e039d9.0 → 0.13.2-dev-ed5ee58.0

package/src/proposals/econ-behaviors.js

@@ -12,19 +12,14 @@ import { E } from '@endo/far';
 import { LienBridgeId, makeStakeReporter } from '../my-lien.js';
 import { makeReserveTerms } from '../reserve/params.js';
 import { makeStakeFactoryTerms } from '../stakeFactory/params.js';
-import { liquidationDetailTerms } from '../vaultFactory/liquidation.js';
 import { makeGovernedTerms } from '../vaultFactory/params.js';
-import { makeAmmTerms } from '../vpool-xyk-amm/params.js';
 
 const trace = makeTracer('RunEconBehaviors', false);
 
-const { Fail } = assert;
-
 const SECONDS_PER_HOUR = 60n * 60n;
 const SECONDS_PER_DAY = 24n * SECONDS_PER_HOUR;
 
 const BASIS_POINTS = 10_000n;
-const MILLI = 1_000_000n;
 
 /**
  * @typedef {GovernedCreatorFacet<import('../stakeFactory/stakeFactory.js').StakeFactoryCreator>} StakeFactoryCreator
@@ -46,13 +41,6 @@ const MILLI = 1_000_000n;
  * @typedef { WellKnownSpaces & ChainBootstrapSpace & EconomyBootstrapSpace
  * } EconomyBootstrapPowers
  * @typedef {PromiseSpaceOf<{
- *   ammKit: {
- *     instanceWithoutReserve: Instance,
- *     creatorFacet: XYKAMMCreatorFacet,
- *     governorCreatorFacet: GovernedContractFacetAccess<XYKAMMPublicFacet,XYKAMMCreatorFacet>,
- *     adminFacet: AdminFacet,
- *     publicFacet: XYKAMMPublicFacet,
- *   },
  *   economicCommitteeCreatorFacet: import('@agoric/governance/src/committee.js').CommitteeElectorateCreatorFacet,
  *   feeDistributorKit: {
  *     creatorFacet: import('../feeDistributor.js').FeeDistributorCreatorFacet,
@@ -96,164 +84,9 @@ const MILLI = 1_000_000n;
  * In production called by @agoric/vats to bootstrap.
  */
 
-/**
- * @param {EconomyBootstrapPowers} powers
- * @param {{
- *   interchainPoolOptions?: { minimumCentral?: bigint }
- * }} [options]
- */
-export const startInterchainPool = async (
-  {
-    consume: { bankManager: mgrP, zoe, agoricNamesAdmin },
-    installation: {
-      consume: { interchainPool: installation },
-    },
-    instance: {
-      consume: { amm },
-      produce: { interchainPool: _viaAgoricNamesAdmin },
-    },
-    brand: {
-      consume: { [Stable.symbol]: centralBrandP },
-    },
-    issuer: {
-      consume: { [Stable.symbol]: centralIssuerP },
-    },
-  },
-  { interchainPoolOptions = {} } = {},
-) => {
-  trace('startInterchainPool');
-  // TODO: get minimumCentral dynamically from the AMM
-  const { minimumCentral = 100n * MILLI } = interchainPoolOptions;
-  const [centralIssuer, centralBrand, bankManager] = await Promise.all([
-    centralIssuerP,
-    centralBrandP,
-    mgrP,
-  ]);
-
-  const terms = await deeplyFulfilledObject(
-    harden({
-      minimumCentral: AmountMath.make(centralBrand, minimumCentral),
-      amm,
-    }),
-  );
-  const { instance } = await E(zoe).startInstance(
-    installation,
-    { Central: centralIssuer },
-    terms,
-    {
-      bankManager,
-    },
-  );
-
-  const instanceAdmin = E(agoricNamesAdmin).lookupAdmin('instance');
-  await E(instanceAdmin).update('interchainPool', instance);
-};
-harden(startInterchainPool);
-
-const AMM_STORAGE_PATH = 'amm'; // TODO: share with agoricNames?
-
-/**
- * @param {EconomyBootstrapPowers} powers
- * @param {{ options?: { minInitialPoolLiquidity?: bigint }}} opts
- */
-export const setupAmm = async (
-  {
-    consume: {
-      board,
-      chainTimerService,
-      zoe,
-      economicCommitteeCreatorFacet: committeeCreator,
-      chainStorage,
-    },
-    produce: { ammKit },
-    brand: {
-      consume: { [Stable.symbol]: runBrandP },
-    },
-    issuer: {
-      consume: { [Stable.symbol]: centralIssuer },
-    },
-    instance: {
-      produce: { ammGovernor },
-    },
-    installation: {
-      consume: { contractGovernor: governorInstallation, amm: ammInstallation },
-    },
-  },
-  { options = {} } = {},
-) => {
-  trace('setupAmm');
-
-  const poserInvitationP = E(committeeCreator).getPoserInvitation();
-  const [poserInvitation, runBrand] = await Promise.all([
-    poserInvitationP,
-    runBrandP,
-  ]);
-  const { minInitialPoolLiquidity = 1_000_000_000n } = options;
-
-  const ammTerms = makeAmmTerms(
-    chainTimerService,
-    E(E(zoe).getInvitationIssuer()).getAmountOf(poserInvitation),
-    AmountMath.make(runBrand, minInitialPoolLiquidity),
-  );
-
-  const storageNode = await makeStorageNodeChild(
-    chainStorage,
-    AMM_STORAGE_PATH,
-  );
-  const marshaller = await E(board).getPublishingMarshaller();
-
-  const ammGovernorTerms = await deeplyFulfilledObject(
-    harden({
-      timer: chainTimerService,
-      governedContractInstallation: ammInstallation,
-      governed: {
-        terms: ammTerms,
-        issuerKeywordRecord: { Central: centralIssuer },
-      },
-    }),
-  );
-
-  /** @type {{ creatorFacet: GovernedContractFacetAccess<XYKAMMPublicFacet,XYKAMMCreatorFacet>, publicFacet: GovernorPublic, instance: Instance, adminFacet: AdminFacet }} */
-  const g = await E(zoe).startInstance(
-    governorInstallation,
-    {},
-    ammGovernorTerms,
-    {
-      electorateCreatorFacet: committeeCreator,
-      governed: {
-        initialPoserInvitation: poserInvitation,
-        storageNode,
-        marshaller,
-      },
-    },
-  );
-
-  const [creatorFacet, ammPublicFacet, instance] = await Promise.all([
-    E(g.creatorFacet).getCreatorFacet(),
-    E(g.creatorFacet).getPublicFacet(),
-    E(g.publicFacet).getGovernedContract(),
-  ]);
-  ammKit.resolve(
-    harden({
-      creatorFacet,
-      instanceWithoutReserve: instance,
-      governorCreatorFacet: g.creatorFacet,
-      adminFacet: g.adminFacet,
-      publicFacet: ammPublicFacet,
-    }),
-  );
-
-  // Confirm that the amm was indeed setup
-  ammPublicFacet || Fail`ammPublicFacet broken  ${ammPublicFacet}`;
-
-  ammGovernor.resolve(g.instance);
-  return ammInstallation;
-};
-
 /** @param {EconomyBootstrapPowers} powers */
 export const setupReserve = async ({
   consume: {
-    ammKit: ammKitP,
     board,
     feeMintAccess: feeMintAccessP,
     chainStorage,
@@ -266,11 +99,7 @@ export const setupReserve = async ({
     consume: { [Stable.symbol]: centralIssuer },
   },
   instance: {
-    produce: {
-      amm: ammInstanceProducer,
-      reserve: reserveInstanceProducer,
-      reserveGovernor,
-    },
+    produce: { reserve: reserveInstanceProducer, reserveGovernor },
   },
   installation: {
     consume: {
@@ -282,17 +111,21 @@ export const setupReserve = async ({
   const STORAGE_PATH = 'reserve';
   trace('setupReserve');
   const poserInvitationP = E(committeeCreator).getPoserInvitation();
-  const [poserInvitation, poserInvitationAmount, feeMintAccess, ammKit] =
+
+  await poserInvitationP;
+  await E(E(zoe).getInvitationIssuer()).getAmountOf(poserInvitationP);
+  await feeMintAccessP;
+
+  const [poserInvitation, poserInvitationAmount, feeMintAccess] =
     await Promise.all([
       poserInvitationP,
       E(E(zoe).getInvitationIssuer()).getAmountOf(poserInvitationP),
       feeMintAccessP,
-      ammKitP,
     ]);
 
   const reserveTerms = makeReserveTerms(
     poserInvitationAmount,
-    ammKit.instanceWithoutReserve,
+    chainTimerService,
   );
 
   const storageNode = await makeStorageNodeChild(chainStorage, STORAGE_PATH);
@@ -342,14 +175,6 @@ export const setupReserve = async ({
   reserveInstanceProducer.resolve(instance);
   reserveGovernor.resolve(g.instance);
 
-  // AMM requires Reserve in order to add pools, but we can't provide it at startInstance
-  // time because Reserve requires AMM itself in order to be started.
-  // Now that we have the reserve, provide it to the AMM.
-  trace('Resolving the reserve public facet on the AMM');
-  await E(ammKit.creatorFacet).resolveReserveFacet(publicFacet);
-  // it now has the reserve
-  ammInstanceProducer.resolve(ammKit.instanceWithoutReserve);
-
   return reserveInstallation;
 };
 
@@ -379,12 +204,11 @@ export const startVaultFactory = async (
     },
     instance: {
       produce: instanceProduce,
-      consume: { amm: ammInstance, reserve: reserveInstance },
+      consume: { reserve: reserveInstance },
     },
     installation: {
       consume: {
         VaultFactory: vaultFactoryInstallation,
-        liquidate: liquidateInstallationP,
         contractGovernor: contractGovernorInstallation,
       },
     },
@@ -405,25 +229,23 @@ export const startVaultFactory = async (
   const shortfallInvitationP = E(
     E.get(reserveKit).creatorFacet,
   ).makeShortfallReportingInvitation();
+
   const [
     initialPoserInvitation,
     poserInvitationAmount,
     initialShortfallInvitation,
     shortfallInvitationAmount,
-    liquidateInstallation,
     feeMintAccess,
   ] = await Promise.all([
     poserInvitationP,
     E(E(zoe).getInvitationIssuer()).getAmountOf(poserInvitationP),
     shortfallInvitationP,
     E(E(zoe).getInvitationIssuer()).getAmountOf(shortfallInvitationP),
-    liquidateInstallationP,
     feeMintAccessP,
   ]);
 
   const centralBrand = await centralBrandP;
 
-  const ammPublicFacet = await E(zoe).getPublicFacet(ammInstance);
   const reservePublicFacet = await E(zoe).getPublicFacet(reserveInstance);
   const storageNode = await makeStorageNodeChild(chainStorage, STORAGE_PATH);
   const marshaller = await E(board).getReadonlyMarshaller();
@@ -434,11 +256,8 @@ export const startVaultFactory = async (
       priceAuthority,
       reservePublicFacet,
       loanTiming: loanParams,
-      liquidationInstall: liquidateInstallation,
       timer: chainTimerService,
       electorateInvitationAmount: poserInvitationAmount,
-      ammPublicFacet,
-      liquidationTerms: liquidationDetailTerms(centralBrand),
       minInitialDebt: AmountMath.make(centralBrand, minInitialDebt),
       bootstrapPaymentValue: 0n,
       shortfallInvitationAmount,
@@ -540,7 +359,6 @@ export const startRewardDistributor = async ({
     bankManager,
     vaultFactoryKit,
     periodicFeeCollectors,
-    ammKit,
     stakeFactoryKit,
     reserveKit,
     zoe,
@@ -620,7 +438,6 @@ export const startRewardDistributor = async ({
 
   const collectorKit = {
     vaultFactory: E.get(vaultFactoryKit).creatorFacet,
-    amm: E.get(ammKit).creatorFacet,
     runStake: E.get(stakeFactoryKit).creatorFacet,
   };
   await Promise.all(

package/src/proposals/sim-behaviors.js

@@ -1,7 +1,7 @@
 import { E, Far } from '@endo/far';
 import { addRemote } from '@agoric/vats/src/core/utils.js';
 
-export { connectFaucet, fundAMM } from './demoIssuers.js';
+export { connectFaucet } from './demoIssuers.js';
 
 /** @param {BootstrapPowers} powers */
 export const installSimEgress = async ({

package/src/reserve/assetReserve.js

@@ -1,24 +1,16 @@
 import { E, Far } from '@endo/far';
 import { AmountMath } from '@agoric/ertp';
-import { handleParamGovernance, ParamTypes } from '@agoric/governance';
-import {
-  offerTo,
-  atomicTransfer,
-} from '@agoric/zoe/src/contractSupport/index.js';
+import { handleParamGovernance } from '@agoric/governance';
+import { atomicTransfer } from '@agoric/zoe/src/contractSupport/index.js';
 import { provideDurableMapStore, prepareKindMulti } from '@agoric/vat-data';
 
 import { makeTracer } from '@agoric/internal';
-import { AMM_INSTANCE } from './params.js';
 import { makeMetricsPublisherKit } from '../contractSupport.js';
 
 const { Fail, quote: q } = assert;
 
 const trace = makeTracer('Reserve', false);
 
-const makeLiquidityKeyword = keyword => `${keyword}Liquidity`;
-
-const nonalphanumeric = /[^A-Za-z0-9]/g;
-
 /**
  * @typedef {object} MetricsNotification
  *
@@ -56,18 +48,11 @@ const nonalphanumeric = /[^A-Za-z0-9]/g;
 
 /**
  * Asset Reserve holds onto assets for the Inter Protocol, and can
- * dispense it for various purposes under governance control. It currently
- * supports governance decisions to add liquidity to an AMM pool.
+ * dispense it for various purposes under governance control.
  *
- * This contract has the ability to mint Fee tokens, granted through its private
- * arguments. When adding liquidity to an AMM pool, it mints new Fee tokens and
- * merges them with the specified amount of collateral on hand. It then deposits
- * both into an AMM pool by using the AMM's method that allows the pool balance
- * to be determined based on the contributed funds.
- *
- * @param {ZCF<GovernanceTerms<{AmmInstance: 'instance'}> &
+ * @param {ZCF<GovernanceTerms<{}> &
  * {
- *   governedApis: ['addLiquidityToAmmPool'],
+ *   governedApis: ['burnFeesToReduceShortfall'],
  * }
  * >} zcf
  * @param {{
@@ -96,13 +81,6 @@ const start = async (zcf, privateArgs, baggage) => {
    * @type {MapStore<Keyword, Brand>}
    */
   const brandForKeyword = provideDurableMapStore(baggage, 'brandForKeyword');
-  /**
-   * @type {MapStore<Brand<'nat'>, Brand<'nat'>>}
-   */
-  const liquidityBrandForBrand = provideDurableMapStore(
-    baggage,
-    'liquidityBrandForBrand',
-  );
 
   /** @type {() => Promise<ZCFMint<'nat'>>} */
   const takeFeeMint = async () => {
@@ -133,22 +111,15 @@ const start = async (zcf, privateArgs, baggage) => {
   saveBrandKeyword(feeKit.brand, 'Fee');
   // no need to saveIssuer() b/c registerFeeMint did it
 
-  const { augmentVirtualPublicFacet, makeVirtualGovernorFacet, params } =
+  const { augmentVirtualPublicFacet, makeVirtualGovernorFacet } =
     await handleParamGovernance(
       zcf,
       privateArgs.initialPoserInvitation,
-      {
-        [AMM_INSTANCE]: ParamTypes.INSTANCE,
-      },
+      {},
       privateArgs.storageNode,
       privateArgs.marshaller,
     );
 
-  /** @type {Promise<XYKAMMPublicFacet>} */
-  const ammPublicFacet = E(zcf.getZoeService()).getPublicFacet(
-    params.getAmmInstance(),
-  );
-
   /**
    * @param {MethodContext} _context
    * @param {Issuer} issuer
@@ -171,71 +142,6 @@ const start = async (zcf, privateArgs, baggage) => {
     await zcf.saveIssuer(issuer, keyword);
   };
 
-  /**
-   * @param {MethodContext} _context
-   * @param {Issuer<'nat'>} baseIssuer on which the liquidity issuer is based
-   */
-  const addLiquidityIssuer = async (_context, baseIssuer) => {
-    const getBrand = () => {
-      try {
-        return zcf.getBrandForIssuer(baseIssuer);
-      } catch {
-        assert.fail(
-          `baseIssuer ${baseIssuer} not known; try addIssuer() first`,
-        );
-      }
-    };
-    const baseBrand = getBrand();
-    const baseKeyword = keywordForBrand.get(baseBrand);
-    const liquidityIssuer = E(ammPublicFacet).getLiquidityIssuer(baseBrand);
-    const liquidityBrand = await E(liquidityIssuer).getBrand();
-    const liquidityKeyword = makeLiquidityKeyword(baseKeyword);
-
-    trace('addLiquidityIssuer', {
-      baseBrand,
-      baseKeyword,
-      liquidityBrand,
-      liquidityKeyword,
-    });
-    saveBrandKeyword(liquidityBrand, liquidityKeyword);
-    liquidityBrandForBrand.init(baseBrand, liquidityBrand);
-
-    await zcf.saveIssuer(liquidityIssuer, liquidityKeyword);
-  };
-
-  const conjureKeyword = async baseBrand => {
-    const allegedName = await E(baseBrand).getAllegedName();
-    const safeName = allegedName.replace(nonalphanumeric, '');
-    let keyword;
-    let keywordNum = 0;
-    do {
-      // 'R' to guarantee leading uppercase
-      keyword = `R${safeName}${keywordNum || ''}`;
-      keywordNum += 1;
-    } while (brandForKeyword.has(keyword));
-    return keyword;
-  };
-
-  /**
-   * @param {MethodContext} context
-   * @param {Brand<'nat'>} ammSecondaryBrand
-   * @returns {Promise<void>}
-   */
-  const addIssuerFromAmm = async (context, ammSecondaryBrand) => {
-    assert(
-      ammSecondaryBrand !== feeKit.brand,
-      'Fee is a special case handled by the reserve contract',
-    );
-
-    const keyword = await conjureKeyword(ammSecondaryBrand);
-    trace('addIssuerFromAmm', { ammSecondaryBrand, keyword });
-    // validate the AMM has this brand and match its issuer
-    const issuer = await E(ammPublicFacet).getSecondaryIssuer(
-      ammSecondaryBrand,
-    );
-    await addIssuer(context, issuer, keyword);
-  };
-
   const getKeywordForBrand = brand => {
     keywordForBrand.has(brand) ||
       Fail`Issuer not defined for brand ${q(brand)}; first call addIssuer()`;
@@ -319,70 +225,6 @@ const start = async (zcf, privateArgs, baggage) => {
     return initialState;
   };
 
-  /**
-   * Takes collateral from the reserve, mints Fee tokens to accompany it, and uses both
-   * to add Liquidity to a pool in the AMM.
-   *
-   * @param {MethodContext} context
-   * @param {Amount<'nat'>} collateral
-   * @param {Amount<'nat'>} fee
-   */
-  const addLiquidityToAmmPool = async ({ state }, collateral, fee) => {
-    // verify we have the funds
-    const collateralKeyword = getKeywordForBrand(collateral.brand);
-    if (
-      !AmountMath.isGTE(
-        collateralSeat.getCurrentAllocation()[collateralKeyword],
-        collateral,
-      )
-    ) {
-      throw new Error('insufficient reserves for that transaction');
-    }
-
-    // create the Fee tokens
-    const offerToSeat = feeMint.mintGains(harden({ Fee: fee }));
-    state.totalFeeMinted = AmountMath.add(state.totalFeeMinted, fee);
-
-    atomicTransfer(zcf, collateralSeat, offerToSeat, {
-      [collateralKeyword]: collateral,
-    });
-
-    // Add Fee tokens and collateral to the AMM
-    const invitation = await E(
-      ammPublicFacet,
-    ).makeAddLiquidityAtRateInvitation();
-    const mapping = harden({
-      Fee: 'Central',
-      [collateralKeyword]: 'Secondary',
-    });
-
-    const liqBrand = liquidityBrandForBrand.get(collateral.brand);
-    const proposal = harden({
-      give: {
-        Central: fee,
-        Secondary: collateral,
-      },
-      want: { Liquidity: AmountMath.makeEmpty(liqBrand) },
-    });
-
-    // chain await the completion of both the offer and the `deposited` promise
-    await E.get(offerTo(zcf, invitation, mapping, proposal, offerToSeat))
-      .deposited;
-
-    // transfer from userSeat to LiquidityToken holdings
-    const liquidityAmount = offerToSeat.getCurrentAllocation();
-    const liquidityKeyword = makeLiquidityKeyword(collateralKeyword);
-
-    atomicTransfer(
-      zcf,
-      offerToSeat,
-      collateralSeat,
-      { Liquidity: liquidityAmount.Liquidity },
-      { [liquidityKeyword]: liquidityAmount.Liquidity },
-    );
-    updateMetrics({ state });
-  };
-
   /**
    *
    * @param {MethodContext} context
@@ -431,13 +273,11 @@ const start = async (zcf, privateArgs, baggage) => {
     getMetrics: () => metricsSubscription,
   });
 
-  const governedApis = { addLiquidityToAmmPool, burnFeesToReduceShortfall };
+  const governedApis = { burnFeesToReduceShortfall };
 
   const publicFacet = augmentVirtualPublicFacet(
     Far('Collateral Reserve public', {
       makeAddCollateralInvitation,
-      addIssuerFromAmm,
-      addLiquidityIssuer,
     }),
   );
 
@@ -467,7 +307,7 @@ export { start };
  * @typedef {object} OriginalAssetReserveCreatorFacet
  * @property {() => Invitation} makeAddCollateralInvitation
  * @property {() => Allocation} getAllocations
- * @property {(issuer: Issuer) => void} addIssuer
+ * @property {(issuer: Issuer, kwd: string) => void} addIssuer
  * @property {() => Invitation<ShortfallReporter>} makeShortfallReportingInvitation
  * @property {() => StoredSubscription<MetricsNotification>} getMetrics
  */
@@ -475,7 +315,6 @@ export { start };
 /**
  * @typedef {object} OriginalAssetReservePublicFacet
  * @property {() => Invitation} makeAddCollateralInvitation
- * @property {(brand: Brand) => void} addIssuerFromAmm
  * @property {(issuer: Issuer) => void} addLiquidityIssuer
  */
 

package/src/reserve/params.js

@@ -1,11 +1,8 @@
 import { CONTRACT_ELECTORATE, ParamTypes } from '@agoric/governance';
 
-export const AMM_INSTANCE = 'AmmInstance';
-
-const makeReserveTerms = (poserInvitationAmount, ammInstance, timer) => ({
+const makeReserveTerms = (poserInvitationAmount, timer) => ({
   timer,
   governedParams: harden({
-    [AMM_INSTANCE]: { type: ParamTypes.INSTANCE, value: ammInstance },
     [CONTRACT_ELECTORATE]: {
       type: ParamTypes.INVITATION,
       value: poserInvitationAmount,