@agoric/inter-protocol 0.13.4-pismo-dev-0d5327f.0 → 0.14.0

package/src/proposals/addAssetToVault.js

@@ -1,9 +1,11 @@
-// @ts-check
+// @jessie-check
+
 import { AmountMath, AssetKind } from '@agoric/ertp';
 import { makeRatio } from '@agoric/zoe/src/contractSupport/index.js';
 import { deeplyFulfilledObject } from '@agoric/internal';
 import { Stable } from '@agoric/vats/src/tokens.js';
 import { E } from '@endo/far';
+import { parseRatio } from '@agoric/zoe/src/contractSupport/ratio.js';
 import { reserveThenGetNames } from './utils.js';
 
 export * from './startPSM.js';
@@ -16,6 +18,7 @@ export * from './startPSM.js';
  * @property {string} [proposedName]
  * @property {string} keyword
  * @property {string} oracleBrand
+ * @property {number} [initialPrice]
  */
 
 /**
@@ -43,44 +46,6 @@ export const publishInterchainAssetFromBoardId = async (
   ]);
 };
 
-const addPool = async (
-  zoe,
-  amm,
-  issuer,
-  keyword,
-  brand,
-  runBrand,
-  runIssuer,
-) => {
-  const ammPub = E(zoe).getPublicFacet(amm);
-  const [addPoolInvitation] = await Promise.all([
-    E(ammPub).addPoolInvitation(),
-    E(ammPub).addIssuer(issuer, keyword),
-  ]);
-  const proposal = harden({
-    give: {
-      Secondary: AmountMath.makeEmpty(brand),
-      Central: AmountMath.makeEmpty(runBrand),
-    },
-  });
-  const centralPurse = E(runIssuer).makeEmptyPurse();
-  const secondaryPurse = E(issuer).makeEmptyPurse();
-  const [emptyCentral, emptySecondary] = await Promise.all([
-    E(centralPurse).withdraw(proposal.give.Central),
-    E(secondaryPurse).withdraw(proposal.give.Secondary),
-  ]);
-  const payments = harden({
-    Central: emptyCentral,
-    Secondary: emptySecondary,
-  });
-  const addLiquiditySeat = await E(zoe).offer(
-    addPoolInvitation,
-    proposal,
-    payments,
-  );
-  await E(addLiquiditySeat).getOfferResult();
-};
-
 /**
  * @param {EconomyBootstrapPowers} powers
  * @param {object} config
@@ -89,20 +54,10 @@ const addPool = async (
  */
 export const publishInterchainAssetFromBank = async (
   {
-    consume: { zoe, bankManager, agoricNamesAdmin, bankMints },
-    produce: { bankMints: produceBankMints },
+    consume: { bankManager, agoricNamesAdmin, reserveKit, startUpgradable },
     installation: {
       consume: { mintHolder },
     },
-    instance: {
-      consume: { amm },
-    },
-    issuer: {
-      consume: { [Stable.symbol]: runIssuer },
-    },
-    brand: {
-      consume: { [Stable.symbol]: stableBrandP },
-    },
   },
   { options: { interchainAssetOptions } },
 ) => {
@@ -124,27 +79,20 @@ export const publishInterchainAssetFromBank = async (
       assetKind: AssetKind.NAT,
     },
   };
-  const { creatorFacet: mintP, publicFacet: issuerP } = E.get(
-    E(zoe).startInstance(mintHolder, {}, terms),
-  );
 
-  const [issuer, brand, runBrand] = await Promise.all([
-    issuerP,
-    E(issuerP).getBrand(),
-    stableBrandP,
-  ]);
-  const kit = { mint: mintP, issuer, brand };
+  const { creatorFacet: mint, publicFacet: issuer } = await E(startUpgradable)({
+    installation: mintHolder,
+    label: keyword,
+    privateArgs: undefined,
+    terms,
+  });
+
+  const brand = await E(issuer).getBrand();
+  const kit = { mint, issuer, brand };
 
-  await addPool(zoe, amm, issuer, keyword, brand, runBrand, runIssuer);
+  await E(E.get(reserveKit).creatorFacet).addIssuer(issuer, keyword);
 
-  // Create the mint list if it doesn't exist and wasn't already rejected.
-  produceBankMints.resolve([]);
   await Promise.all([
-    Promise.resolve(bankMints).then(
-      // @ts-expect-error pushing a promise to a presence array
-      mints => mints.push(mintP),
-      () => {}, // If the bankMints list was rejected, ignore the error.
-    ),
     E(E(agoricNamesAdmin).lookupAdmin('issuer')).update(keyword, issuer),
     E(E(agoricNamesAdmin).lookupAdmin('brand')).update(keyword, brand),
     E(bankManager).addAsset(denom, keyword, proposedName, kit),
@@ -158,16 +106,27 @@ export const publishInterchainAssetFromBank = async (
  * @param {InterchainAssetOptions} config.options.interchainAssetOptions
  */
 export const registerScaledPriceAuthority = async (
-  { consume: { agoricNamesAdmin, zoe, priceAuthorityAdmin, priceAuthority } },
+  {
+    consume: {
+      agoricNamesAdmin,
+      startUpgradable,
+      priceAuthorityAdmin,
+      priceAuthority,
+    },
+  },
   { options: { interchainAssetOptions } },
 ) => {
-  const { keyword, oracleBrand } = interchainAssetOptions;
+  const {
+    keyword,
+    oracleBrand,
+    initialPrice: initialPriceRaw,
+  } = interchainAssetOptions;
   assert.typeof(keyword, 'string');
   assert.typeof(oracleBrand, 'string');
 
   const [
     sourcePriceAuthority,
-    [interchainBrand, runBrand],
+    [interchainBrand, stableBrand],
     [interchainOracleBrand, usdBrand],
     [scaledPriceAuthority],
   ] = await Promise.all([
@@ -201,7 +160,7 @@ export const registerScaledPriceAuthority = async (
     getDecimalP(interchainOracleBrand),
     getDecimalP(interchainBrand),
     getDecimalP(usdBrand),
-    getDecimalP(runBrand),
+    getDecimalP(stableBrand),
   ]);
 
   const scaleIn = makeRatio(
@@ -214,23 +173,32 @@ export const registerScaledPriceAuthority = async (
     10n ** BigInt(decimalPlacesUsd),
     usdBrand,
     10n ** BigInt(decimalPlacesRun),
-    runBrand,
+    stableBrand,
   );
+  const initialPrice = initialPriceRaw
+    ? parseRatio(initialPriceRaw, stableBrand, interchainBrand)
+    : undefined;
 
   const terms = await deeplyFulfilledObject(
     harden({
       sourcePriceAuthority,
       scaleIn,
       scaleOut,
+      initialPrice,
     }),
   );
-  const { publicFacet } = E.get(
-    E(zoe).startInstance(scaledPriceAuthority, undefined, terms),
-  );
+
+  const spaKit = await E(startUpgradable)({
+    installation: scaledPriceAuthority,
+    label: `scaledPriceAuthority-${keyword}`,
+    terms,
+  });
+
   await E(priceAuthorityAdmin).registerPriceAuthority(
-    E(publicFacet).getPriceAuthority(),
+    // @ts-expect-error The public facet should have getPriceAuthority
+    E(spaKit.publicFacet).getPriceAuthority(),
     interchainBrand,
-    runBrand,
+    stableBrand,
     true, // force
   );
 };
@@ -242,15 +210,26 @@ export const registerScaledPriceAuthority = async (
  * @param {object} config
  * @param {object} config.options
  * @param {InterchainAssetOptions} config.options.interchainAssetOptions
+ * @param {bigint | number | string} config.options.debtLimitValue
+ * @param {bigint} config.options.interestRateValue
  */
 export const addAssetToVault = async (
   {
-    consume: { vaultFactoryCreator, agoricNamesAdmin },
+    consume: { vaultFactoryKit, agoricNamesAdmin, auctioneerKit },
     brand: {
       consume: { [Stable.symbol]: stableP },
     },
   },
-  { options: { interchainAssetOptions } },
+  {
+    options: {
+      // Default to 1000 IST to simplify testing. A production proposal will set this.
+      debtLimitValue = 1_000n * 1_000_000n,
+      // Default to a safe value. Production will likely set this through governance.
+      // Allow setting through bootstrap to simplify testing.
+      interestRateValue = 1n,
+      interchainAssetOptions,
+    },
+  },
 ) => {
   const { keyword, oracleBrand } = interchainAssetOptions;
   assert.typeof(keyword, 'string');
@@ -261,19 +240,31 @@ export const addAssetToVault = async (
   );
 
   const stable = await stableP;
+  const vaultFactoryCreator = E.get(vaultFactoryKit).creatorFacet;
   await E(vaultFactoryCreator).addVaultType(interchainIssuer, oracleBrand, {
-    debtLimit: AmountMath.make(stable, 0n),
-    // the rest of these are arbitrary, TBD by gov cttee
-    interestRate: makeRatio(1n, stable),
-    liquidationMargin: makeRatio(1n, stable),
+    debtLimit: AmountMath.make(stable, BigInt(debtLimitValue)),
+    interestRate: makeRatio(interestRateValue, stable),
+    // The rest of these we use safe defaults.
+    // In production they will be governed by the Econ Committee.
+    // Product deployments are also expected to have a low debtLimitValue at the outset,
+    // limiting the impact of these defaults.
+    liquidationPadding: makeRatio(25n, stable),
+    liquidationMargin: makeRatio(150n, stable),
+    mintFee: makeRatio(50n, stable, 10_000n),
     liquidationPenalty: makeRatio(1n, stable),
-    loanFee: makeRatio(1n, stable),
   });
+  const auctioneerCreator = E.get(auctioneerKit).creatorFacet;
+  await E(auctioneerCreator).addBrand(interchainIssuer, keyword);
 };
 
 export const getManifestForAddAssetToVault = (
   { restoreRef },
-  { interchainAssetOptions, scaledPriceAuthorityRef },
+  {
+    debtLimitValue,
+    interestRateValue,
+    interchainAssetOptions,
+    scaledPriceAuthorityRef,
+  },
 ) => {
   const publishIssuerFromBoardId =
     typeof interchainAssetOptions.issuerBoardId === 'string';
@@ -293,26 +284,29 @@ export const getManifestForAddAssetToVault = (
       ...(publishIssuerFromBank && {
         [publishInterchainAssetFromBank.name]: {
           consume: {
-            zoe: true,
             bankManager: true,
             agoricNamesAdmin: true,
             bankMints: true,
+            reserveKit: true,
+            vBankKits: true,
+            startUpgradable: true,
           },
-          produce: { bankMints: true },
+          produce: { bankMints: true, vBankKits: true },
           installation: {
             consume: { mintHolder: true },
           },
-          instance: { consume: { amm: 'amm' } },
-          issuer: { consume: { [Stable.symbol]: 'zoe' } },
-          brand: { consume: { [Stable.symbol]: 'zoe' } },
         },
       }),
       [registerScaledPriceAuthority.name]: {
         consume: {
           agoricNamesAdmin: true,
-          zoe: true,
+          startUpgradable: true,
           priceAuthorityAdmin: true,
           priceAuthority: true,
+          scaledPriceAuthorityKits: true,
+        },
+        produce: {
+          scaledPriceAuthorityKits: true,
         },
         installation: {
           consume: { scaledPriceAuthority: true },
@@ -320,9 +314,8 @@ export const getManifestForAddAssetToVault = (
       },
       [addAssetToVault.name]: {
         consume: {
-          vaultFactoryCreator: true,
-          ammCreatorFacet: true,
-          reserveCreatorFacet: true,
+          auctioneerKit: 'auctioneer',
+          vaultFactoryKit: 'vaultFactory',
           agoricNamesAdmin: true,
         },
         brand: {
@@ -334,7 +327,9 @@ export const getManifestForAddAssetToVault = (
       scaledPriceAuthority: restoreRef(scaledPriceAuthorityRef),
     },
     options: {
+      debtLimitValue,
       interchainAssetOptions,
+      interestRateValue,
     },
   };
 };

package/src/proposals/committee-proposal.js

@@ -1,4 +1,3 @@
-// @ts-check
 import { deeplyFulfilledObject } from '@agoric/internal';
 import { E } from '@endo/far';
 import { reserveThenDeposit } from './utils.js';
@@ -8,67 +7,43 @@ const { values } = Object;
 /** @type { <X, Y>(xs: X[], ys: Y[]) => [X, Y][]} */
 const zip = (xs, ys) => xs.map((x, i) => [x, ys[i]]);
 
+const EC_HIGH_PRIORITY_SENDERS_NAMESPACE = 'economicCommittee';
+
 /**
  * @param {import('./econ-behaviors').EconomyBootstrapPowers} powers
  * @param {{ options: { voterAddresses: Record<string, string> }}} param1
  */
 export const inviteCommitteeMembers = async (
   {
-    consume: {
-      zoe,
-      agoricNames,
-      namesByAddressAdmin,
-      economicCommitteeCreatorFacet,
-      reserveGovernorCreatorFacet,
-      ammGovernorCreatorFacet,
-      vaultFactoryGovernorCreator,
-    },
-    installation: {
-      consume: { binaryVoteCounter: counterP },
-    },
+    consume: { namesByAddressAdmin, economicCommitteeCreatorFacet, ...consume },
   },
   { options: { voterAddresses } },
 ) => {
-  /** @type {[Installation, Installation]} */
-  const [charterInstall, counterInstall] = await Promise.all([
-    E(agoricNames).lookup('installation', 'econCommitteeCharter'),
-    counterP,
-  ]);
-  const terms = await deeplyFulfilledObject(
-    harden({
-      binaryVoteCounterInstallation: counterInstall,
-    }),
-  );
-  const privateFacets = {
-    reserve: reserveGovernorCreatorFacet,
-    amm: ammGovernorCreatorFacet,
-    vaults: vaultFactoryGovernorCreator,
-  };
-  const { publicFacet: votingAPI } = E.get(
-    E(zoe).startInstance(charterInstall, undefined, terms, privateFacets),
-  );
-
   const invitations = await E(
     economicCommitteeCreatorFacet,
   ).getVoterInvitations();
   assert.equal(invitations.length, values(voterAddresses).length);
 
+  const highPrioritySendersManager = await consume.highPrioritySendersManager;
+
   /**
    * @param {[string, Promise<Invitation>][]} addrInvitations
    */
   const distributeInvitations = async addrInvitations => {
     await Promise.all(
       addrInvitations.map(async ([addr, invitationP]) => {
-        const [voterInvitation, nullInvitation] = await Promise.all([
-          invitationP,
-          E(votingAPI).makeNullInvitation(),
-        ]);
         await reserveThenDeposit(
           `econ committee member ${addr}`,
           namesByAddressAdmin,
           addr,
-          [voterInvitation, nullInvitation],
+          [invitationP],
         );
+        if (highPrioritySendersManager) {
+          await E(highPrioritySendersManager).add(
+            EC_HIGH_PRIORITY_SENDERS_NAMESPACE,
+            addr,
+          );
+        }
       }),
     );
   };
@@ -78,6 +53,106 @@ export const inviteCommitteeMembers = async (
 
 harden(inviteCommitteeMembers);
 
+/**
+ * @param {import('./econ-behaviors').EconomyBootstrapPowers} powers
+ */
+export const startEconCharter = async ({
+  consume: { zoe },
+  produce: { econCharterKit },
+  installation: {
+    consume: { binaryVoteCounter: counterP, econCommitteeCharter: installP },
+  },
+  instance: {
+    produce: { econCommitteeCharter: instanceP },
+  },
+}) => {
+  const [charterInstall, counterInstall] = await Promise.all([
+    installP,
+    counterP,
+  ]);
+  const terms = await deeplyFulfilledObject(
+    harden({
+      binaryVoteCounterInstallation: counterInstall,
+    }),
+  );
+
+  /** @type {Promise<import('./econ-behaviors').EconCharterStartResult>} */
+  const startResult = E(zoe).startInstance(
+    charterInstall,
+    undefined,
+    terms,
+    undefined,
+    'econCommitteeCharter',
+  );
+  instanceP.resolve(E.get(startResult).instance);
+  econCharterKit.resolve(startResult);
+};
+harden(startEconCharter);
+
+/**
+ * Introduce charter to governed creator facets.
+ *
+ * @param {import('./econ-behaviors').EconomyBootstrapPowers} powers
+ */
+export const addGovernorsToEconCharter = async ({
+  consume: { reserveKit, vaultFactoryKit, econCharterKit, auctioneerKit },
+  instance: {
+    consume: { reserve, VaultFactory, auctioneer },
+  },
+}) => {
+  const { creatorFacet } = E.get(econCharterKit);
+
+  await Promise.all(
+    [
+      {
+        label: 'reserve',
+        instanceP: reserve,
+        facetP: E.get(reserveKit).governorCreatorFacet,
+      },
+      {
+        label: 'VaultFactory',
+        instanceP: VaultFactory,
+        facetP: E.get(vaultFactoryKit).governorCreatorFacet,
+      },
+      {
+        label: 'auctioneer',
+        instanceP: auctioneer,
+        facetP: E.get(auctioneerKit).governorCreatorFacet,
+      },
+    ].map(async ({ label, instanceP, facetP }) => {
+      const [instance, govFacet] = await Promise.all([instanceP, facetP]);
+
+      return E(creatorFacet).addInstance(instance, govFacet, label);
+    }),
+  );
+};
+
+harden(addGovernorsToEconCharter);
+
+/**
+ * @param {import('./econ-behaviors').EconomyBootstrapPowers} powers
+ * @param {{ options: { voterAddresses: Record<string, string> }}} param1
+ */
+export const inviteToEconCharter = async (
+  { consume: { namesByAddressAdmin, econCharterKit } },
+  { options: { voterAddresses } },
+) => {
+  const { creatorFacet } = E.get(econCharterKit);
+
+  await Promise.all(
+    values(voterAddresses).map(async addr =>
+      reserveThenDeposit(
+        `econ charter member ${addr}`,
+        namesByAddressAdmin,
+        addr,
+        [E(creatorFacet).makeCharterMemberInvitation()],
+      ),
+    ),
+  );
+};
+
+harden(inviteToEconCharter);
+
 export const getManifestForInviteCommittee = async (
   { restoreRef },
   { voterAddresses, econCommitteeCharterRef },
@@ -87,17 +162,43 @@ export const getManifestForInviteCommittee = async (
     manifest: {
       [inviteCommitteeMembers.name]: {
         consume: {
-          zoe: t,
-          agoricNames: t,
           namesByAddressAdmin: t,
           economicCommitteeCreatorFacet: t,
+          highPrioritySendersManager: t,
+        },
+      },
+      [startEconCharter.name]: {
+        consume: { zoe: t },
+        produce: { econCharterKit: t },
+        installation: {
+          consume: { binaryVoteCounter: t, econCommitteeCharter: t },
+        },
+        instance: {
+          produce: { econCommitteeCharter: t },
+        },
+      },
+      [addGovernorsToEconCharter.name]: {
+        consume: {
+          auctioneerKit: t,
           reserveGovernorCreatorFacet: t,
-          ammGovernorCreatorFacet: t,
           vaultFactoryGovernorCreator: t,
+          econCharterKit: t,
+          zoe: t,
+          agoricNames: t,
+          namesByAddressAdmin: t,
+          economicCommitteeCreatorFacet: t,
+          reserveKit: t,
+          vaultFactoryKit: t,
         },
         installation: {
           consume: { binaryVoteCounter: t },
         },
+        instance: {
+          consume: { auctioneer: t, reserve: t, VaultFactory: t },
+        },
+      },
+      [inviteToEconCharter.name]: {
+        consume: { namesByAddressAdmin: t, econCharterKit: t },
       },
     },
     installations: {