@agoric/inter-protocol 0.16.2-other-dev-8f8782b.0 → 0.16.2-other-dev-fbe72e7.0.fbe72e7

package/src/proposals/addAssetToVault.js

@@ -1,12 +1,23 @@
 // @jessie-check
+// @ts-check
 
+import { q } from '@endo/errors';
+import { ToFarFunction } from '@endo/captp';
+import { Far } from '@endo/marshal';
 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 { makeRatio } from '@agoric/zoe/src/contractSupport/index.js';
+import { parseRatio } from '@agoric/ertp/src/ratio.js';
 import { E } from '@endo/far';
-import { parseRatio } from '@agoric/zoe/src/contractSupport/ratio.js';
-import { reserveThenGetNames } from './utils.js';
+import { Stable } from '@agoric/internal/src/tokens.js';
+import { TimeMath } from '@agoric/time/src/timeMath.js';
+import { makePromiseKit } from '@endo/promise-kit';
+
+import {
+  oracleBrandFeedName,
+  reserveThenGetNames,
+  scaledPriceFeedName,
+} from './utils.js';
 
 export * from './startPSM.js';
 
@@ -15,14 +26,18 @@ export * from './startPSM.js';
  * @property {string} [issuerBoardId]
  * @property {string} [denom]
  * @property {number} [decimalPlaces]
- * @property {string} [proposedName]
- * @property {string} keyword
- * @property {string} oracleBrand
+ * @property {string} keyword - used in regstering with reserve, vaultFactory
+ * @property {string} [issuerName] - used in agoricNames for compatibility:
+ *   defaults to `keyword` if not provided
+ * @property {string} [proposedName] - defaults to `issuerName` if not provided
+ * @property {string} [oracleBrand] - defaults to `issuerName` if not provided
  * @property {number} [initialPrice]
  */
 
+/** @import {EconomyBootstrapPowers} from './econ-behaviors.js' */
+
 /**
- * @param {EconomyBootstrapPowers} powers
+ * @param {BootstrapPowers} powers
  * @param {object} config
  * @param {object} config.options
  * @param {InterchainAssetOptions} config.options.interchainAssetOptions
@@ -31,18 +46,22 @@ export const publishInterchainAssetFromBoardId = async (
   { consume: { board, agoricNamesAdmin } },
   { options: { interchainAssetOptions } },
 ) => {
-  const { issuerBoardId, keyword } = interchainAssetOptions;
+  const {
+    issuerBoardId,
+    keyword,
+    issuerName = keyword,
+  } = interchainAssetOptions;
   // Incompatible with denom.
   assert.equal(interchainAssetOptions.denom, undefined);
   assert.typeof(issuerBoardId, 'string');
-  assert.typeof(keyword, 'string');
+  assert.typeof(issuerName, 'string');
 
-  const issuer = await E(board).getValue(issuerBoardId);
+  const issuer = /** @type {Issuer} */ (await E(board).getValue(issuerBoardId));
   const brand = await E(issuer).getBrand();
 
   return Promise.all([
-    E(E(agoricNamesAdmin).lookupAdmin('issuer')).update(keyword, issuer),
-    E(E(agoricNamesAdmin).lookupAdmin('brand')).update(keyword, brand),
+    E(E(agoricNamesAdmin).lookupAdmin('issuer')).update(issuerName, issuer),
+    E(E(agoricNamesAdmin).lookupAdmin('brand')).update(issuerName, brand),
   ]);
 };
 
@@ -61,18 +80,23 @@ export const publishInterchainAssetFromBank = async (
   },
   { options: { interchainAssetOptions } },
 ) => {
-  const { denom, decimalPlaces, proposedName, keyword } =
-    interchainAssetOptions;
+  const {
+    denom,
+    decimalPlaces,
+    keyword,
+    issuerName = keyword,
+    proposedName = keyword,
+  } = interchainAssetOptions;
 
   // Incompatible with issuerBoardId.
   assert.equal(interchainAssetOptions.issuerBoardId, undefined);
   assert.typeof(denom, 'string');
-  assert.typeof(keyword, 'string');
   assert.typeof(decimalPlaces, 'number');
+  assert.typeof(issuerName, 'string');
   assert.typeof(proposedName, 'string');
 
   const terms = {
-    keyword,
+    keyword: issuerName, // "keyword" is a misnomer in mintHolder terms
     assetKind: AssetKind.NAT,
     displayInfo: {
       decimalPlaces,
@@ -82,20 +106,20 @@ export const publishInterchainAssetFromBank = async (
 
   const { creatorFacet: mint, publicFacet: issuer } = await E(startUpgradable)({
     installation: mintHolder,
-    label: keyword,
+    label: issuerName,
     privateArgs: undefined,
     terms,
   });
 
   const brand = await E(issuer).getBrand();
-  const kit = { mint, issuer, brand };
+  const kit = /** @type {IssuerKit<'nat'>} */ ({ mint, issuer, brand });
 
   await E(E.get(reserveKit).creatorFacet).addIssuer(issuer, keyword);
 
   await Promise.all([
-    E(E(agoricNamesAdmin).lookupAdmin('issuer')).update(keyword, issuer),
-    E(E(agoricNamesAdmin).lookupAdmin('brand')).update(keyword, brand),
-    E(bankManager).addAsset(denom, keyword, proposedName, kit),
+    E(E(agoricNamesAdmin).lookupAdmin('issuer')).update(issuerName, issuer),
+    E(E(agoricNamesAdmin).lookupAdmin('brand')).update(issuerName, brand),
+    E(bankManager).addAsset(denom, issuerName, proposedName, kit),
   ]);
 };
 
@@ -105,7 +129,7 @@ export const publishInterchainAssetFromBank = async (
  * @param {object} config.options
  * @param {InterchainAssetOptions} config.options.interchainAssetOptions
  */
-export const registerScaledPriceAuthority = async (
+export const startScaledPriceAuthority = async (
   {
     consume: {
       agoricNamesAdmin,
@@ -118,10 +142,11 @@ export const registerScaledPriceAuthority = async (
 ) => {
   const {
     keyword,
-    oracleBrand,
+    issuerName = keyword,
+    oracleBrand = issuerName,
     initialPrice: initialPriceRaw,
   } = interchainAssetOptions;
-  assert.typeof(keyword, 'string');
+  assert.typeof(issuerName, 'string');
   assert.typeof(oracleBrand, 'string');
 
   const [
@@ -132,7 +157,7 @@ export const registerScaledPriceAuthority = async (
   ] = await Promise.all([
     priceAuthority,
     reserveThenGetNames(E(agoricNamesAdmin).lookupAdmin('brand'), [
-      keyword,
+      issuerName,
       'IST',
     ]),
     reserveThenGetNames(E(agoricNamesAdmin).lookupAdmin('oracleBrand'), [
@@ -144,8 +169,9 @@ export const registerScaledPriceAuthority = async (
     ]),
   ]);
 
+  // TODO get unit amounts elsewhere https://github.com/Agoric/agoric-sdk/issues/10235
   // We need "unit amounts" of each brand in order to get the ratios right.  You
-  // can ignore decimalPlaces when adding and subtracting a brand with itself,
+  // can ignore unit amounts when adding and subtracting a brand with itself,
   // but not when creating ratios.
   const getDecimalP = async brand => {
     const displayInfo = E(brand).getDisplayInfo();
@@ -188,9 +214,11 @@ export const registerScaledPriceAuthority = async (
     }),
   );
 
+  const label = scaledPriceFeedName(issuerName);
+
   const spaKit = await E(startUpgradable)({
     installation: scaledPriceAuthority,
-    label: `scaledPriceAuthority-${keyword}`,
+    label,
     terms,
   });
 
@@ -201,9 +229,100 @@ export const registerScaledPriceAuthority = async (
     stableBrand,
     true, // force
   );
+
+  return spaKit;
+};
+
+/**
+ * @param {BootstrapPowers} powers
+ * @param {object} config
+ * @param {object} config.options
+ */
+export const registerScaledPriceAuthority = async (powers, { options }) => {
+  const {
+    instance: { produce: produceInstance },
+  } = powers;
+
+  const { keyword, issuerName = keyword } = options.interchainAssetOptions;
+
+  const spaKit = await startScaledPriceAuthority(powers, { options });
+
+  const label = scaledPriceFeedName(issuerName);
+
+  // publish into agoricNames so that others can await its presence.
+  // This must stay after registerPriceAuthority above so it's evidence of registration.
+  // eslint-disable-next-line no-restricted-syntax -- computed property
+  produceInstance[label].resolve(spaKit.instance);
 };
 
-/** @typedef {import('./econ-behaviors.js').EconomyBootstrapPowers} EconomyBootstrapPowers */
+// wait a short while after end to allow things to settle
+const BUFFER = 5n * 60n;
+// let's insist on 20 minutes leeway for running the scripts
+const COMPLETION = 20n * 60n;
+
+/**
+ * This function works around an issue identified in #8307 and #8296, and fixed
+ * in #8301. The fix is needed until #8301 makes it into production.
+ *
+ * If there is a liveSchedule, 1) run now if start is far enough away,
+ * otherwise, 2) run after endTime. If neither liveSchedule nor nextSchedule is
+ * defined, 3) run now. If there is only a nextSchedule, 4) run now if startTime
+ * is far enough away, else 5) run after endTime
+ *
+ * @param {import('../auction/scheduler.js').FullSchedule} schedules
+ * @param {ERef<import('@agoric/time').TimerService>} timer
+ * @param {() => void} thunk
+ */
+const whenQuiescent = async (schedules, timer, thunk) => {
+  const { nextAuctionSchedule, liveAuctionSchedule } = schedules;
+  const now = await E(timer).getCurrentTimestamp();
+
+  const waker = Far('addAssetWaker', { wake: () => thunk() });
+
+  if (liveAuctionSchedule) {
+    const safeStart = TimeMath.subtractAbsRel(
+      liveAuctionSchedule.startTime,
+      COMPLETION,
+    );
+
+    if (TimeMath.compareAbs(safeStart, now) < 0) {
+      // case 2
+      console.warn(
+        `Add Asset after live schedule's endtime: ${q(
+          liveAuctionSchedule.endTime,
+        )}`,
+      );
+
+      return E(timer).setWakeup(
+        TimeMath.addAbsRel(liveAuctionSchedule.endTime, BUFFER),
+        waker,
+      );
+    }
+  }
+
+  if (!liveAuctionSchedule && nextAuctionSchedule) {
+    const safeStart = TimeMath.subtractAbsRel(
+      nextAuctionSchedule.startTime,
+      COMPLETION,
+    );
+    if (TimeMath.compareAbs(safeStart, now) < 0) {
+      // case 5
+      console.warn(
+        `Add Asset after next schedule's endtime: ${q(
+          nextAuctionSchedule.endTime,
+        )}`,
+      );
+      return E(timer).setWakeup(
+        TimeMath.addAbsRel(nextAuctionSchedule.endTime, BUFFER),
+        waker,
+      );
+    }
+  }
+
+  // cases 1, 3, and 4 fall through to here.
+  console.warn(`Add Asset immediately`, thunk);
+  return thunk();
+};
 
 /**
  * @param {EconomyBootstrapPowers} powers
@@ -215,10 +334,16 @@ export const registerScaledPriceAuthority = async (
  */
 export const addAssetToVault = async (
   {
-    consume: { vaultFactoryKit, agoricNamesAdmin, auctioneerKit },
+    consume: {
+      vaultFactoryKit,
+      agoricNamesAdmin,
+      auctioneerKit,
+      chainTimerService,
+    },
     brand: {
       consume: { [Stable.symbol]: stableP },
     },
+    instance: { consume: consumeInstance },
   },
   {
     options: {
@@ -231,17 +356,43 @@ export const addAssetToVault = async (
     },
   },
 ) => {
-  const { keyword, oracleBrand } = interchainAssetOptions;
+  const {
+    keyword,
+    issuerName = keyword,
+    oracleBrand = issuerName,
+  } = interchainAssetOptions;
   assert.typeof(keyword, 'string');
+  assert.typeof(issuerName, 'string');
   assert.typeof(oracleBrand, 'string');
   const [interchainIssuer] = await reserveThenGetNames(
     E(agoricNamesAdmin).lookupAdmin('issuer'),
-    [keyword],
+    [issuerName],
   );
 
+  // don't add the collateral offering to vaultFactory until its price feed is available
+  // eslint-disable-next-line no-restricted-syntax -- allow this computed property
+  await consumeInstance[oracleBrandFeedName(oracleBrand, 'USD')];
+  // await also the negotiable brand
+  // eslint-disable-next-line no-restricted-syntax -- allow this computed property
+  await consumeInstance[scaledPriceFeedName(issuerName)];
+
+  const auctioneerCreator = E.get(auctioneerKit).creatorFacet;
+  const schedules = await E(auctioneerCreator).getSchedule();
+
+  const finishPromiseKit = makePromiseKit();
+  const addBrandThenResolve = ToFarFunction('addBrandThenResolve', async () => {
+    await E(auctioneerCreator).addBrand(interchainIssuer, keyword);
+    finishPromiseKit.resolve(undefined);
+  });
+
+  // schedules actions on a timer (or does it immediately).
+  // finishPromiseKit signals completion.
+  void whenQuiescent(schedules, chainTimerService, addBrandThenResolve);
+  await finishPromiseKit.promise;
+
   const stable = await stableP;
   const vaultFactoryCreator = E.get(vaultFactoryKit).creatorFacet;
-  await E(vaultFactoryCreator).addVaultType(interchainIssuer, oracleBrand, {
+  await E(vaultFactoryCreator).addVaultType(interchainIssuer, keyword, {
     debtLimit: AmountMath.make(stable, BigInt(debtLimitValue)),
     interestRate: makeRatio(interestRateValue, stable),
     // The rest of these we use safe defaults.
@@ -253,8 +404,6 @@ export const addAssetToVault = async (
     mintFee: makeRatio(50n, stable, 10_000n),
     liquidationPenalty: makeRatio(1n, stable),
   });
-  const auctioneerCreator = E.get(auctioneerKit).creatorFacet;
-  await E(auctioneerCreator).addBrand(interchainIssuer, keyword);
 };
 
 export const getManifestForAddAssetToVault = (
@@ -286,9 +435,7 @@ export const getManifestForAddAssetToVault = (
           consume: {
             bankManager: true,
             agoricNamesAdmin: true,
-            bankMints: true,
             reserveKit: true,
-            vBankKits: true,
             startUpgradable: true,
           },
           produce: { bankMints: true, vBankKits: true },
@@ -303,10 +450,9 @@ export const getManifestForAddAssetToVault = (
           startUpgradable: true,
           priceAuthorityAdmin: true,
           priceAuthority: true,
-          scaledPriceAuthorityKits: true,
         },
-        produce: {
-          scaledPriceAuthorityKits: true,
+        instance: {
+          produce: true,
         },
         installation: {
           consume: { scaledPriceAuthority: true },
@@ -317,10 +463,16 @@ export const getManifestForAddAssetToVault = (
           auctioneerKit: 'auctioneer',
           vaultFactoryKit: 'vaultFactory',
           agoricNamesAdmin: true,
+          chainTimerService: true,
         },
         brand: {
           consume: { [Stable.symbol]: true },
         },
+        instance: {
+          // allow any instance because the AGORIC_INSTANCE_NAME of
+          // priceFeedOptions cannot be known statically.
+          consume: true,
+        },
       },
     },
     installations: {

package/src/proposals/committee-proposal.js

@@ -4,14 +4,14 @@ import { reserveThenDeposit } from './utils.js';
 
 const { values } = Object;
 
-/** @type { <X, Y>(xs: X[], ys: Y[]) => [X, Y][]} */
+/** @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
+ * @param {import('./econ-behaviors.js').EconomyBootstrapPowers} powers
+ * @param {{ options: { voterAddresses: Record<string, string> } }} param1
  */
 export const inviteCommitteeMembers = async (
   {
@@ -26,18 +26,14 @@ export const inviteCommitteeMembers = async (
 
   const highPrioritySendersManager = await consume.highPrioritySendersManager;
 
-  /**
-   * @param {[string, Promise<Invitation>][]} addrInvitations
-   */
+  /** @param {[string, Promise<Invitation>][]} addrInvitations */
   const distributeInvitations = async addrInvitations => {
     await Promise.all(
       addrInvitations.map(async ([addr, invitationP]) => {
-        await reserveThenDeposit(
-          `econ committee member ${addr}`,
-          namesByAddressAdmin,
-          addr,
-          [invitationP],
-        );
+        const debugName = `econ committee member ${addr}`;
+        await reserveThenDeposit(debugName, namesByAddressAdmin, addr, [
+          invitationP,
+        ]).catch(err => console.error(`failed deposit to ${debugName}`, err));
         if (highPrioritySendersManager) {
           await E(highPrioritySendersManager).add(
             EC_HIGH_PRIORITY_SENDERS_NAMESPACE,
@@ -48,14 +44,14 @@ export const inviteCommitteeMembers = async (
     );
   };
 
-  await distributeInvitations(zip(values(voterAddresses), invitations));
+  // This doesn't resolve until the committee members create their smart wallets.
+  // Don't block bootstrap on it.
+  void distributeInvitations(zip(values(voterAddresses), invitations));
 };
 
 harden(inviteCommitteeMembers);
 
-/**
- * @param {import('./econ-behaviors').EconomyBootstrapPowers} powers
- */
+/** @param {import('./econ-behaviors.js').EconomyBootstrapPowers} powers */
 export const startEconCharter = async ({
   consume: { zoe },
   produce: { econCharterKit },
@@ -76,7 +72,7 @@ export const startEconCharter = async ({
     }),
   );
 
-  /** @type {Promise<import('./econ-behaviors').EconCharterStartResult>} */
+  /** @type {Promise<import('./econ-behaviors.js').EconCharterStartResult>} */
   const startResult = E(zoe).startInstance(
     charterInstall,
     undefined,
@@ -92,7 +88,7 @@ harden(startEconCharter);
 /**
  * Introduce charter to governed creator facets.
  *
- * @param {import('./econ-behaviors').EconomyBootstrapPowers} powers
+ * @param {import('./econ-behaviors.js').EconomyBootstrapPowers} powers
  */
 export const addGovernorsToEconCharter = async ({
   consume: { reserveKit, vaultFactoryKit, econCharterKit, auctioneerKit },
@@ -130,8 +126,8 @@ export const addGovernorsToEconCharter = async ({
 harden(addGovernorsToEconCharter);
 
 /**
- * @param {import('./econ-behaviors').EconomyBootstrapPowers} powers
- * @param {{ options: { voterAddresses: Record<string, string> }}} param1
+ * @param {import('./econ-behaviors.js').EconomyBootstrapPowers} powers
+ * @param {{ options: { voterAddresses: Record<string, string> } }} param1
  */
 export const inviteToEconCharter = async (
   { consume: { namesByAddressAdmin, econCharterKit } },
@@ -139,15 +135,15 @@ export const inviteToEconCharter = async (
 ) => {
   const { creatorFacet } = E.get(econCharterKit);
 
-  await Promise.all(
-    values(voterAddresses).map(async addr =>
-      reserveThenDeposit(
-        `econ charter member ${addr}`,
-        namesByAddressAdmin,
-        addr,
-        [E(creatorFacet).makeCharterMemberInvitation()],
-      ),
-    ),
+  // This doesn't resolve until the committee members create their smart wallets.
+  // Don't block bootstrap on it.
+  void Promise.all(
+    values(voterAddresses).map(async addr => {
+      const debugName = `econ charter member ${addr}`;
+      reserveThenDeposit(debugName, namesByAddressAdmin, addr, [
+        E(creatorFacet).makeCharterMemberInvitation(),
+      ]).catch(err => console.error(`failed deposit to ${debugName}`, err));
+    }),
   );
 };
 
@@ -180,8 +176,6 @@ export const getManifestForInviteCommittee = async (
       [addGovernorsToEconCharter.name]: {
         consume: {
           auctioneerKit: t,
-          reserveGovernorCreatorFacet: t,
-          vaultFactoryGovernorCreator: t,
           econCharterKit: t,
           zoe: t,
           agoricNames: t,

package/src/proposals/core-proposal.js

@@ -1,23 +1,19 @@
 // @jessie-check
 
-import { Stable } from '@agoric/vats/src/tokens.js';
+import { Stable } from '@agoric/internal/src/tokens.js';
 import * as econBehaviors from './econ-behaviors.js';
 import { ECON_COMMITTEE_MANIFEST } from './startEconCommittee.js';
 
 export * from './econ-behaviors.js';
-// @ts-expect-error Module './econ-behaviors.js' has already exported a member
-// named 'EconomyBootstrapPowers'.
-export * from './startPSM.js'; // eslint-disable-line import/export
-export * from './startEconCommittee.js'; // eslint-disable-line import/export
+export * from './startPSM.js';
+export * from './startEconCommittee.js';
 
 // 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
- */
+/** @param {import('./econ-behaviors.js').EconomyBootstrapPowers} powers */
 export const storeInterContractStartKits = async ({
   consume: {
     contractKits,
@@ -31,13 +27,15 @@ export const storeInterContractStartKits = async ({
   },
 }) => {
   /**
-   * @param {Promise<MapStore<string, {instance: Instance}>>} storeP
-   * @param {Promise<{instance: Instance}>[]} kitPs
+   * @param {Promise<MapStore<Instance, { 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));
+    for (const kit of kits) {
+      store.init(kit.instance, kit);
+    }
   };
 
   await storeAll(contractKits, [