@agoric/inter-protocol 0.16.2-upgrade-14-dev-c8f9e7b.0 → 0.16.2-upgrade-16-fi-dev-8879538.0

package/src/proposals/startEconCommittee.js

@@ -21,8 +21,8 @@ const sanitizePathSegment = name => {
  */
 
 /**
- * @param {import('./econ-behaviors').EconomyBootstrapPowers} powers
- * @param {object} [config]
+ * @param {import('./econ-behaviors.js').EconomyBootstrapPowers} powers
+ * @param {object} config
  * @param {object} [config.options]
  * @param {EconCommitteeOptions} [config.options.econCommitteeOptions]
  */

package/src/proposals/startPSM.d.ts

@@ -0,0 +1,59 @@
+export function startPSM({ vatParameters: { chainStorageEntries }, consume: { agoricNamesAdmin, board, diagnostics, zoe, feeMintAccess: feeMintAccessP, economicCommitteeCreatorFacet, econCharterKit, provisionPoolStartResult, chainStorage, chainTimerService, psmKit, anchorBalancePayments: anchorBalancePaymentsP, }, produce: { psmKit: producepsmKit }, installation: { consume: { contractGovernor, psm: psmInstall }, }, brand: { consume: { [Stable.symbol]: mintedP }, }, }: WellKnownSpaces & ChainBootstrapSpace & EconomyBootstrapSpace & ChainStorageVatParams, { options: { anchorOptions }, WantMintedFeeBP, GiveMintedFeeBP, MINT_LIMIT, }?: {
+    WantMintedFeeBP?: bigint | undefined;
+    GiveMintedFeeBP?: bigint | undefined;
+    MINT_LIMIT?: bigint | undefined;
+    options?: {
+        anchorOptions?: AnchorOptions;
+    } | undefined;
+} | undefined): Promise<void>;
+export function makeAnchorAsset({ vatParameters: { chainStorageEntries }, consume: { agoricNamesAdmin, bankManager, startUpgradable, anchorBalancePayments, }, installation: { consume: { mintHolder }, }, produce: { testFirstAnchorKit, anchorBalancePayments: produceAnchorBalancePayments, }, }: WellKnownSpaces & ChainBootstrapSpace & EconomyBootstrapSpace & ChainStorageVatParams, { options: { anchorOptions } }: {
+    options: {
+        anchorOptions?: AnchorOptions;
+    };
+}): Promise<void>;
+/** @import {EconomyBootstrapSpace} from './econ-behaviors.js' */
+export const INVITE_PSM_COMMITTEE_MANIFEST: BootstrapManifest;
+/** @type {BootstrapManifest} */
+export const PSM_MANIFEST: BootstrapManifest;
+export function getManifestForPsmGovernance({ restoreRef }: {
+    restoreRef: any;
+}, { installKeys }: {
+    installKeys: any;
+}): {
+    manifest: {};
+    installations: {
+        econCommitteeCharter: any;
+        contractGovernor: any;
+        committee: any;
+        binaryVoteCounter: any;
+    };
+};
+export function getManifestForPsm({ restoreRef }: {
+    restoreRef: any;
+}, { installKeys, anchorOptions }: {
+    installKeys: any;
+    anchorOptions: any;
+}): {
+    manifest: BootstrapManifest;
+    installations: {
+        psm: any;
+        mintHolder: any;
+    };
+    options: {
+        anchorOptions: any;
+    };
+};
+export type AnchorOptions = {
+    denom?: string | undefined;
+    keyword?: string | undefined;
+    decimalPlaces?: number | undefined;
+    proposedName?: string | undefined;
+};
+import { inviteCommitteeMembers } from './committee-proposal.js';
+import { startEconCharter } from './committee-proposal.js';
+import { inviteToEconCharter } from './committee-proposal.js';
+import type { EconomyBootstrapSpace } from './econ-behaviors.js';
+import { Stable } from '@agoric/internal/src/tokens.js';
+import type { BootstrapManifest } from '@agoric/vats/src/core/lib-boot.js';
+export { inviteCommitteeMembers, startEconCharter, inviteToEconCharter };
+//# sourceMappingURL=startPSM.d.ts.map

package/src/proposals/startPSM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startPSM.d.ts","sourceRoot":"","sources":["startPSM.js"],"names":[],"mappings":"AAuFO;;;;;wBAFsB,aAAa;;8BAsMzC;AAuBM,4ZAFI;IAAE,OAAO,EAAE;QAAE,aAAa,CAAC,EAAE,aAAa,CAAA;KAAE,CAAA;CAAE,iBAoGxD;AAGD,iEAAiE;AAEjE,8DAiBE;AAEF,gCAAgC;AAChC,6CA4CE;AAGK;;;;;;;;;;;;EAaN;AAEM;;;;;;;;;;;;;;EAcN;;;;;;;uCAleM,yBAAyB;iCAAzB,yBAAyB;oCAAzB,yBAAyB;2CAgYS,qBAAqB;uBAxYvC,gCAAgC;uCAUlB,mCAAmC"}

package/src/proposals/startPSM.js

@@ -6,14 +6,14 @@ import { CONTRACT_ELECTORATE, ParamTypes } from '@agoric/governance';
 import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
 import { makeRatio } from '@agoric/zoe/src/contractSupport/index.js';
 import { E } from '@endo/far';
-import { Stable } from '@agoric/vats/src/tokens.js';
 import {
   makeHistoryReviver,
   makeBoardRemote,
   slotToBoardRemote,
-} from '@agoric/vats/tools/board-utils.js';
+} from '@agoric/internal/src/marshal.js';
 import { deeplyFulfilledObject } from '@agoric/internal';
 import { makeScalarBigMapStore } from '@agoric/vat-data';
+import { Stable } from '@agoric/internal/src/tokens.js';
 
 import { reserveThenGetNamePaths } from './utils.js';
 
@@ -23,9 +23,9 @@ import {
   inviteToEconCharter,
 } from './committee-proposal.js';
 
-/** @typedef {import('@agoric/vats/src/core/lib-boot.js').BootstrapManifest} BootstrapManifest */
-/** @typedef {import('../psm/psm.js').MetricsNotification} MetricsNotification */
-/** @typedef {import('./econ-behaviors.js').EconomyBootstrapPowers} EconomyBootstrapPowers */
+/** @import {BootstrapManifest} from '@agoric/vats/src/core/lib-boot.js' */
+/** @import {MetricsNotification} from '../psm/psm.js' */
+/** @import {EconomyBootstrapPowers} from './econ-behaviors.js' */
 
 const BASIS_POINTS = 10000n;
 const { details: X } = assert;
@@ -35,10 +35,13 @@ export { inviteCommitteeMembers, startEconCharter, inviteToEconCharter };
 const stablePsmKey = `published.psm.${Stable.symbol}`;
 
 /**
- * @param {Array<[key: string, value: string]>} chainStorageEntries
+ * @param {[key: string, value: string][]} chainStorageEntries
  * @param {string} keyword
- * @param {{ minted: Brand<'nat'>, anchor: Brand<'nat'> }} brands
- * @returns {{ metrics?: MetricsNotification, governance?: GovernanceSubscriptionState }}
+ * @param {{ minted: Brand<'nat'>; anchor: Brand<'nat'> }} brands
+ * @returns {{
+ *   metrics?: MetricsNotification;
+ *   governance?: GovernanceSubscriptionState;
+ * }}
  */
 const findOldPSMState = (chainStorageEntries, keyword, brands) => {
   // In this reviver, object references are revived as boardIDs
@@ -80,7 +83,7 @@ const findOldPSMState = (chainStorageEntries, keyword, brands) => {
  * @param {bigint} [config.WantMintedFeeBP]
  * @param {bigint} [config.GiveMintedFeeBP]
  * @param {bigint} [config.MINT_LIMIT]
- * @param {{ anchorOptions?: AnchorOptions } } [config.options]
+ * @param {{ anchorOptions?: AnchorOptions }} [config.options]
  */
 export const startPSM = async (
   {
@@ -273,7 +276,6 @@ export const startPSM = async (
       governorFacets.creatorFacet,
       instanceKey,
     ),
-    // @ts-expect-error TODO type for provisionPoolStartResult
     E(E.get(provisionPoolStartResult).creatorFacet).initPSM(
       anchorBrand,
       newpsmKit.psm,
@@ -291,16 +293,16 @@ harden(startPSM);
  */
 
 /**
- * Make anchor issuer out of a Cosmos asset; presumably
- * USDC over IBC. Add it to BankManager.
+ * Make anchor issuer out of a Cosmos asset; presumably USDC over IBC. Add it to
+ * BankManager.
  *
- * Also, if vatParameters shows an anchorPoolBalance for this asset,
- * mint a payment for that balance.
+ * Also, if vatParameters shows an anchorPoolBalance for this asset, mint a
+ * payment for that balance.
  *
  * TODO: address redundancy with publishInterchainAssetFromBank
  *
  * @param {EconomyBootstrapPowers & WellKnownSpaces & ChainStorageVatParams} powers
- * @param {{options?: { anchorOptions?: AnchorOptions } }} [config]
+ * @param {{ options: { anchorOptions?: AnchorOptions } }} config
  */
 export const makeAnchorAsset = async (
   {
@@ -345,17 +347,23 @@ export const makeAnchorAsset = async (
     }),
   );
 
-  /** @type {{ creatorFacet: ERef<Mint<'nat'>>, publicFacet: ERef<Issuer<'nat'>> }} */
-  // @ts-expect-error cast
-  const { creatorFacet: mint, publicFacet: issuer } = await E(startUpgradable)({
-    installation: mintHolder,
-    label: keyword,
-    terms,
-  });
+  const { creatorFacet: mint, publicFacet: issuer } = /**
+   * @type {{
+   *   creatorFacet: ERef<Mint<'nat'>>;
+   *   publicFacet: ERef<Issuer<'nat'>>;
+   * }}
+   */ (
+    await E(startUpgradable)({
+      installation: mintHolder,
+      label: keyword,
+      terms,
+    })
+  );
 
   const brand = await E(issuer).getBrand();
   const kit = harden({ mint, issuer, brand });
 
+  // @ts-expect-error XXX AssetIssuerKit
   testFirstAnchorKit.resolve(kit);
 
   const toSlotReviver = makeHistoryReviver(
@@ -363,23 +371,25 @@ export const makeAnchorAsset = async (
     slotToBoardRemote,
   );
   const metricsKey = `${stablePsmKey}.${keyword}.metrics`;
-  if (toSlotReviver.has(metricsKey)) {
+  const maybeReviveMetrics = async () => {
+    if (!toSlotReviver.has(metricsKey)) {
+      return;
+    }
     const metrics = toSlotReviver.getItem(metricsKey);
     produceAnchorBalancePayments.resolve(
       makeScalarBigMapStore('Anchor balance payments', { durable: true }),
     );
     // XXX this rule should only apply to the 1st await
-    // eslint-disable-next-line @jessie.js/no-nested-await
     const anchorPaymentMap = await anchorBalancePayments;
 
     // TODO: validate that `metrics.anchorPoolBalance.value` is
     // pass-by-copy PureData (e.g., contains no remotables).
-    // eslint-disable-next-line @jessie.js/no-nested-await
     const pmt = await E(mint).mintPayment(
       AmountMath.make(brand, metrics.anchorPoolBalance.value),
     );
     anchorPaymentMap.init(brand, pmt);
-  }
+  };
+  await maybeReviveMetrics();
 
   await Promise.all([
     E(E(agoricNamesAdmin).lookupAdmin('issuer')).update(keyword, kit.issuer),
@@ -388,13 +398,14 @@ export const makeAnchorAsset = async (
       denom,
       keyword,
       proposedName,
+      // @ts-expect-error XXX AssetIssuerKit
       kit, // with mint
     ),
   ]);
 };
 harden(makeAnchorAsset);
 
-/** @typedef {import('./econ-behaviors.js').EconomyBootstrapSpace} EconomyBootstrapSpace */
+/** @import {EconomyBootstrapSpace} from './econ-behaviors.js' */
 
 export const INVITE_PSM_COMMITTEE_MANIFEST = harden(
   /** @type {BootstrapManifest} */ ({

package/src/proposals/upgrade-scaledPriceAuthorities.d.ts

@@ -0,0 +1,24 @@
+export function upgradeScaledPriceAuthorities({ consume: { agoricNamesAdmin, contractKits: contractKitsP, instancePrivateArgs: instancePrivateArgsP, zoe, }, }: ChainBootstrapSpace, { options }: {
+    options: {
+        scaledPARef: {
+            bundleID: string;
+        };
+    };
+}): Promise<void>;
+export function getManifestForUpgradeScaledPriceAuthorities(_ign: any, upgradeSPAOptions: any): Promise<{
+    manifest: {
+        [x: string]: {
+            consume: {
+                agoricNamesAdmin: string;
+                contractKits: string;
+                instancePrivateArgs: string;
+                zoe: string;
+            };
+            instance: {
+                produce: string;
+            };
+        };
+    };
+    options: any;
+}>;
+//# sourceMappingURL=upgrade-scaledPriceAuthorities.d.ts.map

package/src/proposals/upgrade-scaledPriceAuthorities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade-scaledPriceAuthorities.d.ts","sourceRoot":"","sources":["upgrade-scaledPriceAuthorities.js"],"names":[],"mappings":"AASO,gKAHI,mBAAmB,eACnB;IAAE,OAAO,EAAE;QAAE,WAAW,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAA;CAAE,iBAiD5D;AAGM;;;;;;;;;;;;;;;GAkBL"}

package/src/proposals/upgrade-scaledPriceAuthorities.js

@@ -0,0 +1,78 @@
+import { makeTracer } from '@agoric/internal';
+import { E } from '@endo/far';
+
+const trace = makeTracer('upgradeScaledPA', true);
+
+/**
+ * @param {ChainBootstrapSpace} powers
+ * @param {{ options: { scaledPARef: { bundleID: string } } }} options
+ */
+export const upgradeScaledPriceAuthorities = async (
+  {
+    consume: {
+      agoricNamesAdmin,
+      contractKits: contractKitsP,
+      instancePrivateArgs: instancePrivateArgsP,
+      zoe,
+    },
+  },
+  { options },
+) => {
+  trace('start');
+  const { scaledPARef } = options;
+  await null;
+
+  const bundleID = scaledPARef.bundleID;
+  if (scaledPARef && bundleID) {
+    await E.when(
+      E(zoe).installBundleID(bundleID),
+      installation =>
+        E(E(agoricNamesAdmin).lookupAdmin('installation')).update(
+          'scaledPriceAuthority',
+          installation,
+        ),
+      err =>
+        console.error(
+          `🚨 failed to update scaledPriceAuthority installation`,
+          err,
+        ),
+    );
+  }
+
+  const [contractKits, instancePrivateArgs] = await Promise.all([
+    contractKitsP,
+    instancePrivateArgsP,
+  ]);
+  /** @type {StartedInstanceKit<any>[]} */
+  const scaledPAKitEntries = Array.from(contractKits.values()).filter(
+    kit => kit.label && kit.label.match(/scaledPriceAuthority/),
+  );
+
+  for (const kitEntry of scaledPAKitEntries) {
+    const { instance } = kitEntry;
+    const privateArgs = instancePrivateArgs.get(instance);
+    trace('upgrade scaledPriceAuthority', kitEntry.label);
+    await E(kitEntry.adminFacet).upgradeContract(bundleID, privateArgs);
+  }
+};
+
+const t = 'upgradeScaledPriceAuthority';
+export const getManifestForUpgradeScaledPriceAuthorities = async (
+  _ign,
+  upgradeSPAOptions,
+) => ({
+  manifest: {
+    [upgradeScaledPriceAuthorities.name]: {
+      consume: {
+        agoricNamesAdmin: t,
+        contractKits: t,
+        instancePrivateArgs: t,
+        zoe: t,
+      },
+      instance: {
+        produce: t,
+      },
+    },
+  },
+  options: { ...upgradeSPAOptions },
+});

package/src/proposals/upgrade-vaults.d.ts

@@ -0,0 +1,35 @@
+export function upgradeVaults(powers: import("../../src/proposals/econ-behaviors").EconomyBootstrapPowers, { options }: {
+    options: {
+        vaultsRef: {
+            bundleID: string;
+        };
+    };
+}): Promise<void>;
+export function getManifestForUpgradeVaults(_ign: object, vaultUpgradeOptions: any): Promise<{
+    manifest: {
+        [x: string]: {
+            consume: {
+                agoricNamesAdmin: string;
+                newAuctioneerKit: string;
+                economicCommitteeCreatorFacet: string;
+                priceAuthority: string;
+                reserveKit: string;
+                vaultFactoryKit: string;
+                board: string;
+                zoe: string;
+            };
+            produce: {
+                auctioneerKit: string;
+                newAuctioneerKit: string;
+            };
+            instance: {
+                produce: {
+                    auctioneer: string;
+                    newAuctioneerKit: string;
+                };
+            };
+        };
+    };
+    options: any;
+}>;
+//# sourceMappingURL=upgrade-vaults.d.ts.map

package/src/proposals/upgrade-vaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade-vaults.d.ts","sourceRoot":"","sources":["upgrade-vaults.js"],"names":[],"mappings":"AA8BO,sCAHI,OAAO,oCAAoC,EAAE,sBAAsB,eACnE;IAAE,OAAO,EAAE;QAAE,SAAS,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAA;CAAE,iBA+I1D;AASM,kDAHI,MAAM,uBACN,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;GAuBZ"}

package/src/proposals/upgrade-vaults.js

@@ -0,0 +1,202 @@
+import { E } from '@endo/far';
+import { makeNotifierFromAsyncIterable } from '@agoric/notifier';
+import { AmountMath } from '@agoric/ertp/src/index.js';
+import { makeTracer } from '@agoric/internal/src/index.js';
+
+const trace = makeTracer('upgrade Vaults proposal');
+
+// stand-in for Promise.any() which isn't available at this point.
+const any = promises =>
+  new Promise((resolve, reject) => {
+    for (const promise of promises) {
+      promise.then(resolve);
+    }
+    void Promise.allSettled(promises).then(results => {
+      const rejects = results.filter(({ status }) => status === 'rejected');
+      if (rejects.length === results.length) {
+        // @ts-expect-error TypeScript doesn't know enough
+        const messages = rejects.map(({ message }) => message);
+        const aggregate = new Error(messages.join(';'));
+        // @ts-expect-error TypeScript doesn't know enough
+        aggregate.errors = rejects.map(({ reason }) => reason);
+        reject(aggregate);
+      }
+    });
+  });
+
+/**
+ * @param {import('../../src/proposals/econ-behaviors').EconomyBootstrapPowers} powers
+ * @param {{ options: { vaultsRef: { bundleID: string } } }} options
+ */
+export const upgradeVaults = async (powers, { options }) => {
+  const {
+    consume: {
+      agoricNamesAdmin,
+      newAuctioneerKit: auctioneerKitP,
+      priceAuthority,
+      vaultFactoryKit,
+      zoe,
+      economicCommitteeCreatorFacet: electorateCreatorFacet,
+      reserveKit,
+    },
+    produce: {
+      auctioneerKit: auctioneerKitProducer,
+      newAuctioneerKit: tempAuctioneerKit,
+    },
+    instance: {
+      produce: { auctioneer: auctioneerProducer },
+    },
+  } = powers;
+  const { vaultsRef } = options;
+  const kit = await vaultFactoryKit;
+  const auctioneerKit = await auctioneerKitP;
+  const { instance: directorInstance } = kit;
+  const allBrands = await E(zoe).getBrands(directorInstance);
+  const { Minted: istBrand, ...vaultBrands } = allBrands;
+
+  const bundleID = vaultsRef.bundleID;
+  console.log(`upgradeVaults: bundleId`, bundleID);
+  /**
+   * @type {Promise<
+   *   Installation<import('../../src/vaultFactory/vaultFactory.js')['start']>
+   * >}
+   */
+  let installationP;
+  await null;
+  if (vaultsRef) {
+    if (bundleID) {
+      installationP = E(zoe).installBundleID(bundleID);
+      await E.when(
+        installationP,
+        installation =>
+          E(E(agoricNamesAdmin).lookupAdmin('installation')).update(
+            'vaultFactory',
+            installation,
+          ),
+        err =>
+          console.error(`🚨 failed to update vaultFactory installation`, err),
+      );
+    }
+  }
+
+  const readManagerParams = async () => {
+    const { publicFacet: directorPF } = kit;
+
+    await null;
+
+    const params = {};
+    for (const kwd of Object.keys(vaultBrands)) {
+      const collateralBrand = vaultBrands[kwd];
+      const subscription = E(directorPF).getSubscription({
+        collateralBrand,
+      });
+      const notifier = makeNotifierFromAsyncIterable(subscription);
+      let { value, updateCount } = await notifier.getUpdateSince(0n);
+      // @ts-expect-error It's an amount.
+      while (AmountMath.isEmpty(value.current.DebtLimit.value)) {
+        ({ value, updateCount } = await notifier.getUpdateSince(updateCount));
+        trace(`debtLimit was empty, retried`, value.current.DebtLimit.value);
+      }
+      trace(kwd, 'params at', updateCount, 'are', value.current);
+      params[kwd] = harden({
+        brand: collateralBrand,
+        debtLimit: value.current.DebtLimit.value,
+        interestRate: value.current.InterestRate.value,
+        liquidationMargin: value.current.LiquidationMargin.value,
+        liquidationPadding: value.current.LiquidationPadding.value,
+        liquidationPenalty: value.current.LiquidationPenalty.value,
+        mintFee: value.current.MintFee.value,
+      });
+    }
+    return params;
+  };
+  const managerParamValues = await readManagerParams();
+
+  // upgrade the vaultFactory
+  const upgradeVaultFactory = async () => {
+    // @ts-expect-error cast XXX privateArgs missing from type
+    const { privateArgs } = kit;
+
+    const shortfallInvitation = await E(
+      E.get(reserveKit).creatorFacet,
+    ).makeShortfallReportingInvitation();
+
+    const poserInvitation = await E(
+      electorateCreatorFacet,
+    ).getPoserInvitation();
+    /** @type {import('../../src/vaultFactory/vaultFactory').VaultFactoryContract['privateArgs']} */
+    const newPrivateArgs = harden({
+      ...privateArgs,
+      // @ts-expect-error It has a value until reset after the upgrade
+      auctioneerInstance: auctioneerKit.instance,
+      initialPoserInvitation: poserInvitation,
+      initialShortfallInvitation: shortfallInvitation,
+      managerParams: managerParamValues,
+    });
+
+    const upgradeResult = await E(kit.adminFacet).upgradeContract(
+      bundleID,
+      newPrivateArgs,
+    );
+
+    console.log('upgraded vaultFactory.', upgradeResult);
+  };
+
+  // Wait for at least one new price feed to be ready before upgrading Vaults
+  void E.when(
+    any(
+      Object.values(vaultBrands).map(brand =>
+        E(priceAuthority).quoteGiven(AmountMath.make(brand, 10n), istBrand),
+      ),
+    ),
+    async price => {
+      trace(`upgrading after delay`, price);
+      await upgradeVaultFactory();
+      auctioneerKitProducer.reset();
+      // @ts-expect-error auctioneerKit is non-null except between auctioneerKitProducer.reset() and auctioneerKitProducer.resolve()
+      auctioneerKitProducer.resolve(auctioneerKit);
+      auctioneerProducer.reset();
+      // @ts-expect-error auctioneerKit is non-null except between auctioneerKitProducer.reset() and auctioneerKitProducer.resolve()
+      auctioneerProducer.resolve(auctioneerKit.instance);
+      // We wanted it to be valid for only a short while.
+      tempAuctioneerKit.reset();
+      await E(E(agoricNamesAdmin).lookupAdmin('instance')).update(
+        'auctioneer',
+        // @ts-expect-error auctioneerKit is non-null except between auctioneerKitProducer.reset() and auctioneerKitProducer.resolve()
+        auctioneerKit.instance,
+      );
+    },
+  );
+
+  console.log(`upgradeVaults scheduled; waiting for priceFeeds`);
+};
+
+const uV = 'upgradeVaults';
+/**
+ * Return the manifest, installations, and options for upgrading Vaults.
+ *
+ * @param {object} _ign
+ * @param {any} vaultUpgradeOptions
+ */
+export const getManifestForUpgradeVaults = async (
+  _ign,
+  vaultUpgradeOptions,
+) => ({
+  manifest: {
+    [upgradeVaults.name]: {
+      consume: {
+        agoricNamesAdmin: uV,
+        newAuctioneerKit: uV,
+        economicCommitteeCreatorFacet: uV,
+        priceAuthority: uV,
+        reserveKit: uV,
+        vaultFactoryKit: uV,
+        board: uV,
+        zoe: uV,
+      },
+      produce: { auctioneerKit: uV, newAuctioneerKit: uV },
+      instance: { produce: { auctioneer: uV, newAuctioneerKit: uV } },
+    },
+  },
+  options: { ...vaultUpgradeOptions },
+});

package/src/proposals/utils.d.ts

@@ -0,0 +1,17 @@
+export function reserveThenGetNamePaths(nameAdmin: ERef<import("@agoric/vats").NameAdmin>, paths: string[][]): Promise<any[]>;
+export function reserveThenGetNames(nameAdmin: ERef<import("@agoric/vats").NameAdmin>, names: string[]): Promise<any[]>;
+export function reserveThenDeposit(debugName: string, namesByAddressAdmin: ERef<import("@agoric/vats").NameAdmin>, addr: string, payments: ERef<Payment>[]): Promise<void>;
+export function makeInstallCache(homeP: {
+    scratch: ERef<import("@agoric/internal/src/scratch.js").ScratchPad>;
+}, { installCacheKey, loadBundle }: {
+    loadBundle: (specifier: string) => Promise<{
+        default: Bundle;
+    }>;
+    installCacheKey?: string | undefined;
+}): Promise<{
+    wrapInstall: (install: any) => (mPath: any, bPath: any, opts: any) => Promise<any>;
+    saveCache: () => Promise<void>;
+}>;
+export function oracleBrandFeedName(inBrandName: any, outBrandName: any): string;
+export function scaledPriceFeedName(issuerName: any): string;
+//# sourceMappingURL=utils.d.ts.map

package/src/proposals/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["utils.js"],"names":[],"mappings":"AAYO,mDAHI,IAAI,CAAC,OAAO,cAAc,EAAE,SAAS,CAAC,SACtC,MAAM,EAAE,EAAE,kBA+BpB;AAMM,+CAHI,IAAI,CAAC,OAAO,cAAc,EAAE,SAAS,CAAC,SACtC,MAAM,EAAE,kBAMhB;AAQI,8CALI,MAAM,uBACN,IAAI,CAAC,OAAO,cAAc,EAAE,SAAS,CAAC,QACtC,MAAM,YACN,IAAI,CAAC,OAAO,CAAC,EAAE,iBAuBzB;AA6BM,wCAPI;IACV,OAAW,EAAE,IAAI,CAAC,OAAO,iCAAiC,EAAE,UAAU,CAAC,CAAC;CACrE;4BAEmB,MAAM;;;;;;;GAqD5B;AAEM,iFACsC;AAEtC,6DAC+B"}