@agoric/inter-protocol 0.16.2-upgrade-14-dev-0169c7e.0 → 0.16.2-upgrade-16-dev-8879538.0

package/src/proposals/addAssetToVault.js

@@ -1,28 +1,44 @@
 // @jessie-check
+// @ts-check
 
+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 { E } from '@endo/far';
+import { makeRatio } from '@agoric/zoe/src/contractSupport/index.js';
 import { parseRatio } from '@agoric/zoe/src/contractSupport/ratio.js';
-import { reserveThenGetNames } from './utils.js';
+import { E } from '@endo/far';
+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';
 
+const { quote: q } = assert;
+
 /**
  * @typedef {object} InterchainAssetOptions
  * @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 +47,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 +81,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 +107,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),
   ]);
 };
 
@@ -113,15 +138,17 @@ export const registerScaledPriceAuthority = async (
       priceAuthorityAdmin,
       priceAuthority,
     },
+    instance: { produce: produceInstance },
   },
   { options: { interchainAssetOptions } },
 ) => {
   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 +159,7 @@ export const registerScaledPriceAuthority = async (
   ] = await Promise.all([
     priceAuthority,
     reserveThenGetNames(E(agoricNamesAdmin).lookupAdmin('brand'), [
-      keyword,
+      issuerName,
       'IST',
     ]),
     reserveThenGetNames(E(agoricNamesAdmin).lookupAdmin('oracleBrand'), [
@@ -188,9 +215,11 @@ export const registerScaledPriceAuthority = async (
     }),
   );
 
+  const label = scaledPriceFeedName(issuerName);
+
   const spaKit = await E(startUpgradable)({
     installation: scaledPriceAuthority,
-    label: `scaledPriceAuthority-${keyword}`,
+    label,
     terms,
   });
 
@@ -201,9 +230,81 @@ export const registerScaledPriceAuthority = async (
     stableBrand,
     true, // force
   );
+
+  // 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 +316,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 +338,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 +386,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 +417,7 @@ export const getManifestForAddAssetToVault = (
           consume: {
             bankManager: true,
             agoricNamesAdmin: true,
-            bankMints: true,
             reserveKit: true,
-            vBankKits: true,
             startUpgradable: true,
           },
           produce: { bankMints: true, vBankKits: true },
@@ -303,10 +432,9 @@ export const getManifestForAddAssetToVault = (
           startUpgradable: true,
           priceAuthorityAdmin: true,
           priceAuthority: true,
-          scaledPriceAuthorityKits: true,
         },
-        produce: {
-          scaledPriceAuthorityKits: true,
+        instance: {
+          produce: true,
         },
         installation: {
           consume: { scaledPriceAuthority: true },
@@ -317,10 +445,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.d.ts

@@ -0,0 +1,113 @@
+export function inviteCommitteeMembers({ consume: { namesByAddressAdmin, economicCommitteeCreatorFacet, ...consume }, }: import("./econ-behaviors.js").EconomyBootstrapPowers, { options: { voterAddresses } }: {
+    options: {
+        voterAddresses: Record<string, string>;
+    };
+}): Promise<void>;
+export function startEconCharter({ consume: { zoe }, produce: { econCharterKit }, installation: { consume: { binaryVoteCounter: counterP, econCommitteeCharter: installP }, }, instance: { produce: { econCommitteeCharter: instanceP }, }, }: import("./econ-behaviors.js").EconomyBootstrapPowers): Promise<void>;
+export function addGovernorsToEconCharter({ consume: { reserveKit, vaultFactoryKit, econCharterKit, auctioneerKit }, instance: { consume: { reserve, VaultFactory, auctioneer }, }, }: import("./econ-behaviors.js").EconomyBootstrapPowers): Promise<void>;
+export function inviteToEconCharter({ consume: { namesByAddressAdmin, econCharterKit } }: import("./econ-behaviors.js").EconomyBootstrapPowers, { options: { voterAddresses } }: {
+    options: {
+        voterAddresses: Record<string, string>;
+    };
+}): Promise<void>;
+export function getManifestForInviteCommittee({ restoreRef }: {
+    restoreRef: any;
+}, { voterAddresses, econCommitteeCharterRef }: {
+    voterAddresses: any;
+    econCommitteeCharterRef: any;
+}): Promise<{
+    manifest: {
+        [x: string]: {
+            consume: {
+                namesByAddressAdmin: boolean;
+                economicCommitteeCreatorFacet: boolean;
+                highPrioritySendersManager: boolean;
+                zoe?: undefined;
+                auctioneerKit?: undefined;
+                econCharterKit?: undefined;
+                agoricNames?: undefined;
+                reserveKit?: undefined;
+                vaultFactoryKit?: undefined;
+            };
+            produce?: undefined;
+            installation?: undefined;
+            instance?: undefined;
+        } | {
+            consume: {
+                zoe: boolean;
+                namesByAddressAdmin?: undefined;
+                economicCommitteeCreatorFacet?: undefined;
+                highPrioritySendersManager?: undefined;
+                auctioneerKit?: undefined;
+                econCharterKit?: undefined;
+                agoricNames?: undefined;
+                reserveKit?: undefined;
+                vaultFactoryKit?: undefined;
+            };
+            produce: {
+                econCharterKit: boolean;
+            };
+            installation: {
+                consume: {
+                    binaryVoteCounter: boolean;
+                    econCommitteeCharter: boolean;
+                };
+            };
+            instance: {
+                produce: {
+                    econCommitteeCharter: boolean;
+                };
+                consume?: undefined;
+            };
+        } | {
+            consume: {
+                auctioneerKit: boolean;
+                econCharterKit: boolean;
+                zoe: boolean;
+                agoricNames: boolean;
+                namesByAddressAdmin: boolean;
+                economicCommitteeCreatorFacet: boolean;
+                reserveKit: boolean;
+                vaultFactoryKit: boolean;
+                highPrioritySendersManager?: undefined;
+            };
+            installation: {
+                consume: {
+                    binaryVoteCounter: boolean;
+                    econCommitteeCharter?: undefined;
+                };
+            };
+            instance: {
+                consume: {
+                    auctioneer: boolean;
+                    reserve: boolean;
+                    VaultFactory: boolean;
+                };
+                produce?: undefined;
+            };
+            produce?: undefined;
+        } | {
+            consume: {
+                namesByAddressAdmin: boolean;
+                econCharterKit: boolean;
+                economicCommitteeCreatorFacet?: undefined;
+                highPrioritySendersManager?: undefined;
+                zoe?: undefined;
+                auctioneerKit?: undefined;
+                agoricNames?: undefined;
+                reserveKit?: undefined;
+                vaultFactoryKit?: undefined;
+            };
+            produce?: undefined;
+            installation?: undefined;
+            instance?: undefined;
+        };
+    };
+    installations: {
+        econCommitteeCharter: any;
+    };
+    options: {
+        voterAddresses: any;
+    };
+}>;
+//# sourceMappingURL=committee-proposal.d.ts.map

package/src/proposals/committee-proposal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"committee-proposal.d.ts","sourceRoot":"","sources":["committee-proposal.js"],"names":[],"mappings":"AAeO,yHAHI,OAAO,qBAAqB,EAAE,sBAAsB,mCACpD;IAAE,OAAO,EAAE;QAAE,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAA;CAAE,iBAoCjE;AAKM,+OADK,OAAO,qBAAqB,EAAE,sBAAsB,iBA+B/D;AAQM,uLAFI,OAAO,qBAAqB,EAAE,sBAAsB,iBAiC9D;AAQM,0FAHI,OAAO,qBAAqB,EAAE,sBAAsB,mCACpD;IAAE,OAAO,EAAE;QAAE,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAA;CAAE,iBAkBjE;AAIM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDN"}

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,