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

package/src/proposals/startPSM.js

@@ -1,19 +1,20 @@
 // @jessie-check
 
 import { makeMap } from 'jessie.js';
+import { X } from '@endo/errors';
+import { E } from '@endo/far';
 import { AmountMath, AssetKind } from '@agoric/ertp';
 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,22 +24,24 @@ 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;
 
 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,27 @@ 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,
-  });
+  /**
+   * @typedef {{
+   *   creatorFacet: ERef<Mint<'nat'>>;
+   *   publicFacet: ERef<Issuer<'nat'>>;
+   * }} PsmKit
+   */
+
+  const { creatorFacet: mint, publicFacet: issuer } =
+    /** @type {PsmKit} */
+    (
+      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 +375,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 +402,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.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.js

@@ -0,0 +1,207 @@
+/**
+ * @file this core-eval proposal is specific to the upgrade-18 scenario,
+ *   handling tasks beyond generic Vault Factory null upgrade. For a reusable
+ *   proposal, see upgrade-vaultFactory-proposal.js.
+ */
+
+import { E } from '@endo/far';
+import { makeNotifierFromAsyncIterable } from '@agoric/notifier';
+import { makeTracer } from '@agoric/internal/src/index.js';
+import { Fail } from '@endo/errors';
+import { TimeMath } from '@agoric/time';
+
+const trace = makeTracer('upgrade Vaults proposal');
+
+/**
+ * @typedef {PromiseSpaceOf<{
+ *   priceAuthority8400: Instance;
+ *   auctionUpgradeNewInstance: Instance;
+ *   newContractGovBundleId: string;
+ * }>} interlockPowers
+ */
+
+/**
+ * @param {import('../../src/proposals/econ-behaviors').EconomyBootstrapPowers &
+ *     interlockPowers} powers
+ * @param {{
+ *   options: {
+ *     VaultFactoryBundle: { bundleID: string };
+ *   };
+ * }} options
+ */
+export const upgradeVaults = async (
+  {
+    consume: {
+      auctionUpgradeNewInstance,
+      chainTimerService,
+      economicCommitteeCreatorFacet: electorateCreatorFacet,
+      reserveKit,
+      vaultFactoryKit,
+      zoe,
+      priceAuthority8400,
+      newContractGovBundleId: newContractGovBundleIdP,
+    },
+    produce: {
+      auctionUpgradeNewInstance: auctionUpgradeNewInstanceProducer,
+      newContractGovBundleId: newContractGovBundleIdErasor,
+    },
+  },
+  { options: { VaultFactoryBundle: vaultBundleRef } },
+) => {
+  const kit = await vaultFactoryKit;
+  const { instance: directorInstance } = kit;
+  const allBrands = await E(zoe).getBrands(directorInstance);
+  const { Minted: _istBrand, ...vaultBrands } = allBrands;
+
+  await priceAuthority8400;
+
+  /** @type {Instance<import('../auction/auctioneer.js').start>} */
+  const auctionNewInstance = await auctionUpgradeNewInstance;
+  auctionUpgradeNewInstanceProducer.reset();
+  const publicFacet = E(zoe).getPublicFacet(auctionNewInstance);
+  const schedules = await E(publicFacet).getSchedules();
+  const now = await E(chainTimerService).getCurrentTimestamp();
+  (schedules.nextAuctionSchedule &&
+    TimeMath.compareAbs(schedules.nextAuctionSchedule.startTime, now) > 0) ||
+    Fail`Expected next start time in the future ${schedules.nextAuctionSchedule?.startTime}`;
+
+  const readCurrentDirectorParams = async () => {
+    const { publicFacet: directorPF } = kit;
+
+    await null;
+
+    const subscription = E(directorPF).getElectorateSubscription();
+    const notifier = makeNotifierFromAsyncIterable(subscription);
+    const { updateCount } = await notifier.getUpdateSince();
+
+    // subscribeAfter(<some known state>) retrieves the latest value.
+    const after = await E(subscription).subscribeAfter(updateCount);
+    const { current } = after.head.value;
+
+    return harden({
+      MinInitialDebt: current.MinInitialDebt.value,
+      ReferencedUI: current.ReferencedUI.value,
+      RecordingPeriod: current.RecordingPeriod.value,
+      ChargingPeriod: current.ChargingPeriod.value,
+    });
+  };
+  const directorParamOverrides = await readCurrentDirectorParams();
+  trace({ directorParamOverrides });
+
+  const readManagerParams = async () => {
+    const { publicFacet: directorPF } = kit;
+
+    await null;
+
+    const params = {};
+    for (const kwd of Object.keys(vaultBrands)) {
+      const collateralBrand = vaultBrands[kwd];
+
+      const governedParams = await E(directorPF).getGovernedParams({
+        collateralBrand,
+      });
+      trace({ kwd, governedParams });
+      params[kwd] = harden({
+        brand: collateralBrand,
+        debtLimit: governedParams.DebtLimit.value,
+        interestRate: governedParams.InterestRate.value,
+        liquidationMargin: governedParams.LiquidationMargin.value,
+        liquidationPadding: governedParams.LiquidationPadding.value,
+        liquidationPenalty: governedParams.LiquidationPenalty.value,
+        mintFee: governedParams.MintFee.value,
+      });
+      trace(kwd, params[kwd]);
+    }
+    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,
+      auctioneerInstance: auctionNewInstance,
+      initialPoserInvitation: poserInvitation,
+      initialShortfallInvitation: shortfallInvitation,
+      managerParams: managerParamValues,
+      directorParamOverrides,
+    });
+
+    const upgradeResult = await E(kit.adminFacet).upgradeContract(
+      vaultBundleRef.bundleID,
+      newPrivateArgs,
+    );
+
+    trace('upgraded vaultFactory.', upgradeResult);
+  };
+  await upgradeVaultFactory();
+
+  // @ts-expect-error It's saved in econ-behaviors.js:startVaultFactory()
+  const vaultFactoryPrivateArgs = kit.privateArgs;
+  trace('restarting governor');
+
+  const [ecf, newContractGovBundleId] = await Promise.all([
+    electorateCreatorFacet,
+    newContractGovBundleIdP,
+  ]);
+  newContractGovBundleIdErasor.reset();
+
+  // upgrade vaultFactory governor. Won't be needed next time: see #10063
+  await E(kit.governorAdminFacet).upgradeContract(
+    newContractGovBundleId,
+    harden({
+      electorateCreatorFacet: ecf,
+      governed: vaultFactoryPrivateArgs,
+    }),
+  );
+
+  trace('restarted governor');
+};
+
+const uV = 'upgradeVaults';
+/**
+ * Return the manifest, installations, and options for upgrading Vaults.
+ *
+ * @param {object} utils
+ * @param {any} utils.restoreRef
+ * @param {any} vaultUpgradeOptions
+ */
+export const getManifestForUpgradeVaults = async (
+  { restoreRef },
+  { VaultFactoryRef },
+) => {
+  return {
+    manifest: {
+      [upgradeVaults.name]: {
+        consume: {
+          priceAuthority8400: uV,
+          auctionUpgradeNewInstance: uV,
+          chainTimerService: uV,
+          economicCommitteeCreatorFacet: uV,
+          reserveKit: uV,
+          vaultFactoryKit: uV,
+          zoe: uV,
+          newContractGovBundleId: uV,
+        },
+        produce: {
+          auctionUpgradeNewInstance: uV,
+          newContractGovBundleId: uV,
+        },
+      },
+    },
+    installations: { VaultFactory: restoreRef(VaultFactoryRef) },
+    options: { VaultFactoryBundle: VaultFactoryRef },
+  };
+};

package/src/proposals/utils.d.ts

@@ -0,0 +1,21 @@
+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: Promise<{
+    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;
+/** @type {(name: string) => string} */
+export const sanitizePathSegment: (name: string) => string;
+export function provideRetiredInstances(consume: Promise<MapStore>, produce: Producer<MapStore>): Promise<MapStore>;
+import type { MapStore } from '@agoric/store';
+//# 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":"AAgBO,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,OAAO,CAAC;IACd,OAAO,EAAE,IAAI,CAAC,OAAO,iCAAiC,EAAE,UAAU,CAAC,CAAC;CACrE,CAAC,mCAEF;IAAkE,UAAU,EAApE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IACrC,eAAe;CAAC;oCAkCD,UAAK,EAAE,UAAK,EAAE,SAAI;;GAkBzD;AAEM,iFACsC;AAEtC,6DAC+B;AAEtC,uCAAuC;AACvC,kCADW,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAKjC;AAUK,iDAJI,OAAO,CAAC,QAAQ,CAAC,WACjB,QAAQ,CAAC,QAAQ,CAAC,GAChB,OAAO,CAAC,QAAQ,CAAC,CAW7B;8BA1LoC,eAAe"}

package/src/proposals/utils.js

@@ -1,8 +1,14 @@
+import { Fail } from '@endo/errors';
+import { E } from '@endo/far';
 import { WalletName } from '@agoric/internal';
 import { getCopyMapEntries, makeCopyMap } from '@agoric/store';
-import { E } from '@endo/far';
+import { assertPathSegment } from '@agoric/internal/src/lib-chainStorage.js';
+import { makeScalarBigMapStore } from '@agoric/vat-data';
 
-const { Fail } = assert;
+/**
+ * @import {CopyMap} from '@endo/patterns';
+ * @import {MapStore, SetStore} from '@agoric/store';
+ */
 
 /**
  * @param {ERef<import('@agoric/vats').NameAdmin>} nameAdmin
@@ -10,7 +16,6 @@ const { Fail } = assert;
  */
 export const reserveThenGetNamePaths = async (nameAdmin, paths) => {
   /**
-   *
    * @param {ERef<import('@agoric/vats').NameAdmin>} nextAdmin
    * @param {string[]} path
    */
@@ -54,7 +59,7 @@ export const reserveThenGetNames = async (nameAdmin, names) =>
  * @param {string} debugName
  * @param {ERef<import('@agoric/vats').NameAdmin>} namesByAddressAdmin
  * @param {string} addr
- * @param {Array<ERef<Payment>>} payments
+ * @param {ERef<Payment>[]} payments
  */
 export const reserveThenDeposit = async (
   debugName,
@@ -79,7 +84,15 @@ export const reserveThenDeposit = async (
   );
 };
 
-/** @type {<T>(store: ERef<Map<string, T> | import('@agoric/internal/src/scratch.js').ScratchPad>, key: string, make: () => T) => Promise<T>} */
+/**
+ * @type {<T>(
+ *   store: ERef<
+ *     Map<string, T> | import('@agoric/internal/src/scratch.js').ScratchPad
+ *   >,
+ *   key: string,
+ *   make: () => T,
+ * ) => Promise<T>}
+ */
 const provideWhen = async (store, key, make) => {
   const found = await E(store).get(key);
   if (found) {
@@ -91,21 +104,33 @@ const provideWhen = async (store, key, make) => {
 };
 
 /**
- * @param {{ scratch: ERef<import('@agoric/internal/src/scratch.js').ScratchPad> }} homeP
+ * @param {Promise<{
+ *   scratch: ERef<import('@agoric/internal/src/scratch.js').ScratchPad>;
+ * }>} homeP
  * @param {object} opts
- * @param {(specifier: string) => Promise<{default: Bundle}>} opts.loadBundle
+ * @param {(specifier: string) => Promise<{ default: Bundle }>} opts.loadBundle
  * @param {string} [opts.installCacheKey]
  */
 export const makeInstallCache = async (
   homeP,
   { installCacheKey = 'installCache', loadBundle },
 ) => {
-  /** @type {CopyMap<string, {installation: Installation, boardId: string, path?: string}>} */
+  /**
+   * @type {CopyMap<
+   *   string,
+   *   { installation: Installation; boardId: string; path?: string }
+   * >}
+   */
   const initial = await provideWhen(E.get(homeP).scratch, installCacheKey, () =>
     makeCopyMap([]),
   );
   // ISSUE: getCopyMapEntries of CopyMap<K, V> loses K, V.
-  /** @type {Map<string, {installation: Installation, boardId: string, path?: string}>} */
+  /**
+   * @type {Map<
+   *   string,
+   *   { installation: Installation; boardId: string; path?: string }
+   * >}
+   */
   const working = new Map(getCopyMapEntries(initial));
 
   const saveCache = async () => {
@@ -137,3 +162,35 @@ export const makeInstallCache = async (
 
   return { wrapInstall, saveCache };
 };
+
+export const oracleBrandFeedName = (inBrandName, outBrandName) =>
+  `${inBrandName}-${outBrandName} price feed`;
+
+export const scaledPriceFeedName = issuerName =>
+  `scaledPriceAuthority-${issuerName}`;
+
+/** @type {(name: string) => string} */
+export const sanitizePathSegment = name => {
+  const candidate = name.replace(/ /g, '_');
+  assertPathSegment(candidate);
+  return candidate;
+};
+
+/**
+ * Idempotently provide an empty MapStore for the `retiredContractInstances`
+ * value in promise space
+ *
+ * @param {Promise<MapStore>} consume
+ * @param {Producer<MapStore>} produce
+ * @returns {Promise<MapStore>}
+ */
+export const provideRetiredInstances = async (consume, produce) => {
+  // Promise space has no way to look for an existing value other than awaiting a promise,
+  // but it does allow extra production so it's safe to do this redundantly.
+  produce.resolve(
+    makeScalarBigMapStore('retiredContractInstances', {
+      durable: true,
+    }),
+  );
+  return consume;
+};

package/src/proposals/withdraw-reserve-proposal.js

@@ -0,0 +1,63 @@
+import { E } from '@endo/far';
+import { makeTracer } from '@agoric/internal/src/debug.js';
+import { reserveThenDeposit } from './utils.js';
+
+/**
+ * @param {BootstrapPowers & {
+ *   consume: {
+ *     reserveKit: Promise<
+ *       ReturnType<import('../reserve/assetReserve.js')['start']>
+ *     >;
+ *   };
+ * }} powers
+ * @param {{ options: { address: string; count?: number } }} namedArgs
+ */
+export const inviteReserveWithdrawer = async (
+  { consume: { namesByAddressAdmin, reserveKit } },
+  { options: { address, count = 1 } },
+) => {
+  const trace = makeTracer('InviteReserveWithdrawer');
+
+  const maybeGovernedCreatorFacetP = E.get(reserveKit).creatorFacet;
+  const creatorFacetP = E(maybeGovernedCreatorFacetP)
+    .getLimitedCreatorFacet()
+    .catch(err => {
+      trace('Failed to get limited creator facet:', err);
+      return maybeGovernedCreatorFacetP;
+    });
+
+  const makeInvitation = () =>
+    // @ts-expect-error tolerate translation from governed to limited creatorFacet
+    E(creatorFacetP).makeSingleWithdrawalInvitation();
+
+  const invitations = await Promise.all(
+    Array.from({ length: count }, makeInvitation),
+  );
+
+  // Deposit the invitations, but don't block in case the address does not yet
+  // have a smart wallet.
+  void reserveThenDeposit(
+    `reserve withdrawer ${address}`,
+    namesByAddressAdmin,
+    address,
+    invitations,
+  );
+};
+harden(inviteReserveWithdrawer);
+
+export const getManifestForInviteWithdrawer = async (
+  { restoreRef: _ },
+  { address, count },
+) => {
+  return {
+    manifest: {
+      [inviteReserveWithdrawer.name]: /** @type {const} */ ({
+        consume: {
+          namesByAddressAdmin: true,
+          reserveKit: true,
+        },
+      }),
+    },
+    options: { address, count },
+  };
+};