@agoric/inter-protocol 0.16.2-other-dev-3eb1a1d.0 → 0.16.2-other-dev-fbe72e7.0.fbe72e7

package/src/provisionPoolKit.js

@@ -1,7 +1,6 @@
 // @ts-check
 import { X, q, Fail } from '@endo/errors';
 import { E } from '@endo/far';
-import { Far } from '@endo/marshal';
 
 import { AmountMath, BrandShape } from '@agoric/ertp';
 import { deeplyFulfilledObject, makeTracer } from '@agoric/internal';
@@ -15,8 +14,8 @@ import {
   M,
   makeScalarBigMapStore,
   makeScalarBigSetStore,
-  prepareExoClassKit,
 } from '@agoric/vat-data';
+import { makeAtomicProvider, makeScalarMapStore } from '@agoric/store';
 import { PowerFlags } from '@agoric/vats/src/walletFlags.js';
 import {
   PublicTopicShape,
@@ -25,16 +24,31 @@ import {
 import { InstanceHandleShape } from '@agoric/zoe/src/typeGuards.js';
 import { isUpgradeDisconnection } from '@agoric/internal/src/upgrade-api.js';
 
+/**
+ * @import {EReturn} from '@endo/far';
+ * @import {BridgeMessage} from '@agoric/cosmic-swingset/src/types.js';
+ * @import {Amount, Brand, Payment, Purse} from '@agoric/ertp';
+ * @import {StorageNode} from '@agoric/internal/src/lib-chainStorage.js';
+ * @import {ZCF} from '@agoric/zoe';
+ * @import {ERef} from '@endo/far'
+ * @import {Bank, BankManager} from '@agoric/vats/src/vat-bank.js'
+ * @import {MapStore, SetStore} from '@agoric/store';
+ */
+
 const trace = makeTracer('ProvPool');
 
 const FIRST_UPPER_KEYWORD = /^[A-Z][a-zA-Z0-9_$]*$/;
 // see https://github.com/Agoric/agoric-sdk/issues/8238
 const FIRST_LOWER_NEAR_KEYWORD = /^[a-z][a-zA-Z0-9_$]*$/;
 
+// XXX when inferred, error TS2742: cannot be named without a reference to '../../../node_modules/@endo/exo/src/get-interface.js'. This is likely not portable. A type annotation is necessary.
 /**
- * @import {ERef} from '@endo/far'
- * @import {Amount} from '@agoric/ertp/src/types.js'
- * @import {Bank, BankManager} from '@agoric/vats/src/vat-bank.js'
+ * @typedef {{
+ *   machine: any;
+ *   helper: any;
+ *   forHandler: any;
+ *   public: any;
+ * }} ProvisionPoolKit
  */
 
 /**
@@ -66,28 +80,48 @@ const FIRST_LOWER_NEAR_KEYWORD = /^[a-z][a-zA-Z0-9_$]*$/;
  * Given attenuated access to the funding purse, handle requests to provision
  * smart wallets.
  *
- * @param {(depositBank: ERef<Bank>) => Promise<void>} sendInitialPayment
- * @param {() => void} onProvisioned
+ * @param {import('@agoric/zone').Zone} zone
  */
-export const makeBridgeProvisionTool = (sendInitialPayment, onProvisioned) => {
-  /** @param {ProvisionPoolKitReferences} refs */
-  const makeBridgeHandler = ({
-    bankManager,
-    namesByAddressAdmin,
-    walletFactory,
-  }) =>
-    Far('provisioningHandler', {
-      fromBridge: async obj => {
-        obj.type === 'PLEASE_PROVISION' ||
-          Fail`Unrecognized request ${obj.type}`;
+export const prepareBridgeProvisionTool = zone =>
+  zone.exoClass(
+    'smartWalletProvisioningHandler',
+    M.interface('ProvisionBridgeHandlerMaker', {
+      fromBridge: M.callWhen(M.record()).returns(),
+    }),
+    /**
+     * @param {ERef<BankManager>} bankManager
+     * @param {ERef<
+     *   EReturn<
+     *     import('@agoric/smart-wallet/src/walletFactory.js').start
+     *   >['creatorFacet']
+     * >} walletFactory
+     * @param {ERef<import('@agoric/vats').NameAdmin>} namesByAddressAdmin
+     * @param {ProvisionPoolKit['forHandler']} forHandler
+     */
+    (bankManager, walletFactory, namesByAddressAdmin, forHandler) => ({
+      bankManager,
+      walletFactory,
+      namesByAddressAdmin,
+      forHandler,
+    }),
+    {
+      /** @param {BridgeMessage} obj */
+      async fromBridge(obj) {
+        if (obj.type !== 'PLEASE_PROVISION')
+          throw Fail`Unrecognized request ${obj.type}`;
         trace('PLEASE_PROVISION', obj);
         const { address, powerFlags } = obj;
+        // XXX expects powerFlags to be an array, but if it's a string then
+        // this allows a string that has 'SMART_WALLET' in it.
         powerFlags.includes(PowerFlags.SMART_WALLET) ||
           Fail`missing SMART_WALLET in powerFlags`;
 
+        const { bankManager, walletFactory, namesByAddressAdmin, forHandler } =
+          this.state;
+
         const bank = E(bankManager).getBankForAddress(address);
         // only proceed if we can provide funds
-        await sendInitialPayment(bank);
+        await forHandler.sendInitialPayment(bank);
 
         const [_, created] = await E(walletFactory).provideSmartWallet(
           address,
@@ -95,31 +129,44 @@ export const makeBridgeProvisionTool = (sendInitialPayment, onProvisioned) => {
           namesByAddressAdmin,
         );
         if (created) {
-          onProvisioned();
+          forHandler.onProvisioned();
         }
         trace(created ? 'provisioned' : 're-provisioned', address);
       },
-    });
-  return makeBridgeHandler;
-};
+    },
+  );
 
 /**
- * @param {import('@agoric/vat-data').Baggage} baggage
+ * @param {import('@agoric/zone').Zone} zone
  * @param {{
  *   makeRecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit;
  *   params: any;
  *   poolBank: import('@endo/far').ERef<Bank>;
  *   zcf: ZCF;
+ *   makeBridgeProvisionTool: ReturnType<typeof prepareBridgeProvisionTool>;
  * }} powers
  */
 export const prepareProvisionPoolKit = (
-  baggage,
-  { makeRecorderKit, params, poolBank, zcf },
+  zone,
+  { makeRecorderKit, params, poolBank, zcf, makeBridgeProvisionTool },
 ) => {
   const zoe = zcf.getZoeService();
+  const ephemeralPurses = makeScalarMapStore('fundingPurseForBrand');
+  const purseProvider = makeAtomicProvider(ephemeralPurses);
+  const getFundingPurseForBrand = async poolBrand => {
+    await null;
+    try {
+      const purse = await purseProvider.provideAsync(poolBrand, brand =>
+        E(poolBank).getPurse(brand),
+      );
+      return purse;
+    } catch (err) {
+      trace(`🚨 could not get purse for brand ${poolBrand}`, err);
+      throw err;
+    }
+  };
 
-  const makeProvisionPoolKitInternal = prepareExoClassKit(
-    baggage,
+  const makeProvisionPoolKitInternal = zone.exoClassKit(
     'ProvisionPoolKit',
     {
       machine: M.interface('ProvisionPoolKit machine', {
@@ -142,13 +189,14 @@ export const prepareProvisionPoolKit = (
         ackWallet: M.call(M.string()).returns(M.boolean()),
       }),
       helper: UnguardedHelperI,
+      forHandler: UnguardedHelperI,
       public: M.interface('ProvisionPoolKit public', {
         getPublicTopics: M.call().returns({ metrics: PublicTopicShape }),
       }),
     },
     /**
      * @param {object} opts
-     * @param {Purse<'nat'>} opts.fundPurse
+     * @param {Purse<'nat'>} [opts.fundPurse]
      * @param {Brand<'nat'>} opts.poolBrand
      * @param {StorageNode} opts.metricsNode
      */
@@ -208,23 +256,24 @@ export const prepareProvisionPoolKit = (
           const refs = await deeplyFulfilledObject(obj);
           Object.assign(this.state, refs);
         },
+        /** @returns {import('@agoric/vats').BridgeHandler} */
         makeHandler() {
           const { bankManager, namesByAddressAdmin, walletFactory } =
             this.state;
           if (!bankManager || !namesByAddressAdmin || !walletFactory) {
             throw Fail`must set references before handling requests`;
           }
-          const { helper } = this.facets;
-          // a bit obtuse but leave for backwards compatibility with tests
-          const innerMaker = makeBridgeProvisionTool(
-            bank => helper.sendInitialPayment(bank),
-            () => helper.onProvisioned(),
-          );
-          return innerMaker({
+
+          const { forHandler } = this.facets;
+
+          const provisionHandler = makeBridgeProvisionTool(
             bankManager,
-            namesByAddressAdmin,
             walletFactory,
-          });
+            namesByAddressAdmin,
+            forHandler,
+          );
+
+          return provisionHandler;
         },
         /**
          * @param {Brand} brand
@@ -302,66 +351,43 @@ export const prepareProvisionPoolKit = (
           );
           facets.helper.publishMetrics();
         },
-        onProvisioned() {
-          const { state, facets } = this;
-          state.walletsProvisioned += 1n;
-          facets.helper.publishMetrics();
-        },
-        /** @param {ERef<Bank>} destBank */
-        async sendInitialPayment(destBank) {
-          const {
-            facets: { helper },
-            state: { fundPurse, poolBrand },
-          } = this;
-          const perAccountInitialAmount = /** @type {Amount<'nat'>} */ (
-            params.getPerAccountInitialAmount()
-          );
-          const initialPmt = await E(fundPurse).withdraw(
-            perAccountInitialAmount,
-          );
+        /**
+         * @param {Amount} amount
+         * @param {ERef<Purse>} srcPurse
+         */
+        async onPoolDeposit(amount, srcPurse) {
+          const { helper } = this.facets;
+          const { brandToPSM, poolBrand } = this.state;
 
-          const destPurse = E(destBank).getPurse(poolBrand);
-          return E(destPurse)
-            .deposit(initialPmt)
-            .then(amt => {
-              helper.onSendFunds(perAccountInitialAmount);
-              trace('provisionPool sent', amt);
-            })
-            .catch(reason => {
-              console.error(X`initial deposit failed: ${q(reason)}`);
-              void E(fundPurse).deposit(initialPmt);
-              throw reason;
-            });
+          const { brand } = amount;
+          if (AmountMath.isEmpty(amount) || brand === poolBrand) {
+            return;
+          }
+
+          // `amount` doesn't match the current `poolBrand`, so we need to swap
+          // it.
+          if (!brandToPSM.has(brand)) {
+            console.error('funds arrived but no PSM instance', brand);
+            return;
+          }
+          const instance = brandToPSM.get(brand);
+          const payment = E(srcPurse).withdraw(amount);
+          await helper.swap(payment, amount, instance).catch(async reason => {
+            console.error(X`swap failed: ${reason}`);
+            const resolvedPayment = await payment;
+            return E(srcPurse).deposit(resolvedPayment);
+          });
         },
         /**
          * @param {ERef<Purse>} exchangePurse
          * @param {ERef<Brand>} brand
          */
         watchCurrentAmount(exchangePurse, brand) {
-          const {
-            state: { brandToPSM, poolBrand },
-            facets: { helper },
-          } = this;
-
+          const { helper } = this.facets;
           void observeNotifier(E(exchangePurse).getCurrentAmountNotifier(), {
             updateState: async amount => {
               trace('provisionPool balance update', amount);
-              if (AmountMath.isEmpty(amount) || amount.brand === poolBrand) {
-                return;
-              }
-              if (!brandToPSM.has(brand)) {
-                console.error('funds arrived but no PSM instance', brand);
-                return;
-              }
-              const instance = brandToPSM.get(brand);
-              const payment = E(exchangePurse).withdraw(amount);
-              await helper
-                .swap(payment, amount, instance)
-                .catch(async reason => {
-                  console.error(X`swap failed: ${reason}`);
-                  const resolvedPayment = await payment;
-                  return E(exchangePurse).deposit(resolvedPayment);
-                });
+              await helper.onPoolDeposit(amount, exchangePurse);
             },
             fail: reason => {
               if (isUpgradeDisconnection(reason)) {
@@ -427,40 +453,50 @@ export const prepareProvisionPoolKit = (
           );
         },
         /**
+         * @param {Brand<'nat'>} poolBrand
          * @param {object} [options]
          * @param {MetricsNotification} [options.metrics]
          */
-        start({ metrics } = {}) {
-          const {
-            state: { poolBrand },
-            facets: { helper },
-          } = this;
+        start(poolBrand, { metrics } = {}) {
+          const { facets, state } = this;
+          const { helper } = facets;
+          const lastPoolBrand = state.poolBrand;
 
-          // Must match. poolBrand is from durable state and the param is from
-          // the contract, so it technically can change between incarnations.
-          // That would be a severe bug.
+          // The PerAccountInitialAmount param must use the correct brand for
+          // this incarnation.
           AmountMath.coerce(poolBrand, params.getPerAccountInitialAmount());
 
-          void helper.watchAssetSubscription();
-
+          // Restore old metrics.
           if (metrics) {
-            // Restore state.
-            // we publishMetrics() below
             const {
               walletsProvisioned,
               totalMintedProvided,
               totalMintedConverted,
             } = metrics;
             assert.typeof(walletsProvisioned, 'bigint');
-            AmountMath.coerce(poolBrand, totalMintedProvided);
-            AmountMath.coerce(poolBrand, totalMintedConverted);
-            Object.assign(this.state, {
+            AmountMath.coerce(lastPoolBrand, totalMintedProvided);
+            AmountMath.coerce(lastPoolBrand, totalMintedConverted);
+            Object.assign(state, {
               walletsProvisioned,
               totalMintedProvided,
               totalMintedConverted,
             });
             helper.publishMetrics();
           }
+
+          // Update as needed when `poolBrand` changes.
+          if (poolBrand !== lastPoolBrand) {
+            state.poolBrand = poolBrand;
+            state.fundPurse = undefined;
+            void getFundingPurseForBrand(poolBrand).then(purse =>
+              helper.updateFundPurse(purse, poolBrand),
+            );
+            state.totalMintedProvided = AmountMath.makeEmpty(poolBrand);
+            state.totalMintedConverted = AmountMath.makeEmpty(poolBrand);
+            helper.publishMetrics();
+          }
+
+          void helper.watchAssetSubscription();
         },
         /**
          * @param {ERef<Payment>} payIn
@@ -468,10 +504,13 @@ export const prepareProvisionPoolKit = (
          * @param {PsmInstance} instance
          */
         async swap(payIn, amount, instance) {
+          await null;
+          const { facets, state } = this;
+          const { helper } = facets;
           const {
-            facets: { helper },
-            state: { fundPurse },
-          } = this;
+            poolBrand,
+            fundPurse = await getFundingPurseForBrand(poolBrand),
+          } = state;
           const psmPub = E(zoe).getPublicFacet(instance);
           const proposal = harden({ give: { In: amount } });
           const invitation = E(psmPub).makeWantMintedInvitation();
@@ -481,6 +520,52 @@ export const prepareProvisionPoolKit = (
           helper.onTrade(rxd);
           return rxd;
         },
+        /**
+         * @param {Purse<'nat'>} purse
+         * @param {Brand<'nat'>} brand
+         */
+        updateFundPurse(purse, brand) {
+          const { state } = this;
+          if (brand !== state.poolBrand || state.fundPurse) return;
+          state.fundPurse = purse;
+        },
+      },
+      forHandler: {
+        onProvisioned() {
+          const { facets, state } = this;
+          state.walletsProvisioned += 1n;
+          facets.helper.publishMetrics();
+        },
+        /** @param {ERef<Bank>} destBank */
+        async sendInitialPayment(destBank) {
+          await null;
+          const { facets, state } = this;
+          const { helper } = facets;
+          const {
+            poolBrand,
+            fundPurse = await getFundingPurseForBrand(poolBrand),
+          } = state;
+          const perAccountInitialAmount = /** @type {Amount<'nat'>} */ (
+            params.getPerAccountInitialAmount()
+          );
+          trace('sendInitialPayment withdrawing', perAccountInitialAmount);
+          const initialPmt = await E(fundPurse).withdraw(
+            perAccountInitialAmount,
+          );
+
+          const destPurse = E(destBank).getPurse(poolBrand);
+          return E(destPurse)
+            .deposit(initialPmt)
+            .then(amt => {
+              helper.onSendFunds(perAccountInitialAmount);
+              trace('provisionPool sent', amt);
+            })
+            .catch(reason => {
+              console.error(X`initial deposit failed: ${q(reason)}`);
+              void E(fundPurse).deposit(initialPmt);
+              throw reason;
+            });
+        },
       },
       public: {
         getPublicTopics() {
@@ -506,9 +591,10 @@ export const prepareProvisionPoolKit = (
    * @param {object} opts
    * @param {Brand<'nat'>} opts.poolBrand
    * @param {ERef<StorageNode>} opts.storageNode
+   * @returns {Promise<ProvisionPoolKit>}
    */
   const makeProvisionPoolKit = async ({ poolBrand, storageNode }) => {
-    const fundPurse = await E(poolBank).getPurse(poolBrand);
+    const fundPurse = await getFundingPurseForBrand(poolBrand);
     const metricsNode = await E(storageNode).makeChildNode('metrics');
 
     return makeProvisionPoolKitInternal({

package/src/psm/psm.d.ts

@@ -5,6 +5,10 @@
  *   economic policies, the fee percentage for trading into and out of the
  *   stable token are specified separately.
  */
+/**
+ * @import {EReturn} from '@endo/far';
+ * @import {ContractMeta, FeeMintAccess, Installation} from '@agoric/zoe';
+ */
 /**
  * @typedef {object} MetricsNotification Metrics naming scheme is that nouns are
  *   present values and past-participles are accumulative.
@@ -47,7 +51,7 @@ export function start(zcf: ZCF<GovernanceTerms<{
             } & {
                 Electorate: "invitation";
             }>;
-        } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        } & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
             get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
                 GiveMintedFee: "ratio";
                 MintLimit: "amount";
@@ -56,11 +60,11 @@ export function start(zcf: ZCF<GovernanceTerms<{
                 Electorate: "invitation";
             }>;
         }>;
-        getInvitation: (name: any) => Promise<Invitation<unknown, undefined>>;
+        getInvitation: (name: any) => Promise<globalThis.Invitation>;
         getLimitedCreatorFacet: () => import("@endo/exo").Guarded<{
             getRewardAllocation(): Allocation;
-            makeCollectFeesInvitation(): Promise<Invitation<string, undefined>>;
-            makeRestoreMetricsInvitation(): Promise<Invitation<void, Omit<MetricsNotification, "anchorPoolBalance">>>;
+            makeCollectFeesInvitation(): Promise<globalThis.Invitation<string>>;
+            makeRestoreMetricsInvitation(): Promise<globalThis.Invitation<void, Omit<MetricsNotification, "anchorPoolBalance">>>;
         }>;
         getGovernedApis: () => GovernedApis;
         getGovernedApiNames: () => string[];
@@ -85,8 +89,8 @@ export function start(zcf: ZCF<GovernanceTerms<{
         getPublicTopics(): {
             metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<MetricsNotification>;
         };
-        makeWantMintedInvitation(): Promise<Invitation<void, undefined>>;
-        makeGiveMintedInvitation(): Promise<Invitation<void, undefined>>;
+        makeWantMintedInvitation(): Promise<globalThis.Invitation<void, undefined>>;
+        makeGiveMintedInvitation(): Promise<globalThis.Invitation<void, undefined>>;
     }>;
 }>;
 /**
@@ -120,6 +124,10 @@ export type MetricsNotification = {
      */
     totalMintedProvided: Amount<"nat">;
 };
-export type PsmPublicFacet = Awaited<ReturnType<typeof start>>["publicFacet"];
+export type PsmPublicFacet = EReturn<typeof start>["publicFacet"];
+import type { ContractMeta } from '@agoric/zoe';
+import type { FeeMintAccess } from '@agoric/zoe';
 import type { Baggage } from '@agoric/vat-data';
+import type { Installation } from '@agoric/zoe';
+import type { EReturn } from '@endo/far';
 //# sourceMappingURL=psm.d.ts.map

package/src/psm/psm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"psm.d.ts","sourceRoot":"","sources":["psm.js"],"names":[],"mappings":"AAqCA;;;;;;GAMG;AAEH;;;;;;;;;;;;;GAaG;AAEH;;;GAGG;AAEH,2BAA2B;AAC3B,mBADW,YAAY,CAkCrB;AAsBK,2BAlBI,GAAG,CACT,eAAe,CAAC;IACd,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,QAAQ,CAAC;CACrB,CAAC,GAAG;IACH,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IAC1B,eAAe,EAAE,KAAK,CAAC;CACxB,CACF,eACO;IACN,aAAa,EAAE,aAAa,CAAC;IAC7B,sBAAsB,EAAE,UAAU,CAAC;IACnC,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,UAAU,CAAC;CACxB,WACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+CAsU4F,cAAc;kDAAuE,cAAc;;;;;;;;;;;;GAJhN;;;;;;;;;;uBAzYa,MAAM,CAAC,KAAK,CAAC;;;;;uBAEb,MAAM,CAAC,KAAK,CAAC;;;;;oBAEb,MAAM,CAAC,KAAK,CAAC;;;;;yBAEb,MAAM,CAAC,KAAK,CAAC;;;;;yBAEb,MAAM,CAAC,KAAK,CAAC;;6BAoYb,OAAO,CAAC,UAAU,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC;6BA9XpC,kBAAkB"}
+{"version":3,"file":"psm.d.ts","sourceRoot":"","sources":["psm.js"],"names":[],"mappings":"AAqCA;;;;;;GAMG;AAEH;;;GAGG;AAEH;;;;;;;;;;;;;GAaG;AAEH;;;GAGG;AAEH,2BAA2B;AAC3B,mBADW,YAAY,CAkCrB;AAsBK,2BAlBI,GAAG,CACT,eAAe,CAAC;IACd,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,QAAQ,CAAC;CACrB,CAAC,GAAG;IACH,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IAC1B,eAAe,EAAE,KAAK,CAAC;CACxB,CACF,eACO;IACN,aAAa,EAAE,aAAa,CAAC;IAC7B,sBAAsB,EAAE,UAAU,CAAC;IACnC,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,UAAU,CAAC;CACxB,WACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkUjB;;;;;;;;;;uBAzYa,MAAM,CAAC,KAAK,CAAC;;;;;uBAEb,MAAM,CAAC,KAAK,CAAC;;;;;oBAEb,MAAM,CAAC,KAAK,CAAC;;;;;yBAEb,MAAM,CAAC,KAAK,CAAC;;;;;yBAEb,MAAM,CAAC,KAAK,CAAC;;6BAoYb,QAAQ,OAAO,KAAK,CAAb,CAAe,aAAa,CAAC;kCAlZU,aAAa;mCAAb,aAAa;6BAoB/C,kBAAkB;kCApBgB,aAAa;6BAD/C,WAAW"}

package/src/psm/psm.js

@@ -43,6 +43,11 @@ import { makeNatAmountShape } from '../contractSupport.js';
  *   stable token are specified separately.
  */
 
+/**
+ * @import {EReturn} from '@endo/far';
+ * @import {ContractMeta, FeeMintAccess, Installation} from '@agoric/zoe';
+ */
+
 /**
  * @typedef {object} MetricsNotification Metrics naming scheme is that nouns are
  *   present values and past-participles are accumulative.
@@ -442,4 +447,4 @@ export const start = async (zcf, privateArgs, baggage) => {
 };
 harden(start);
 
-/** @typedef {Awaited<ReturnType<typeof start>>['publicFacet']} PsmPublicFacet */
+/** @typedef {EReturn<typeof start>['publicFacet']} PsmPublicFacet */

package/src/reserve/assetReserve.d.ts

@@ -12,14 +12,19 @@ export function start(zcf: ZCF<GovernanceTerms<{}> & {
     creatorFacet: GovernedCreatorFacet<import("@endo/exo").Guarded<{
         addIssuer(issuer: Issuer, keyword: string): Promise<void>;
         getAllocations(): Allocation;
-        makeShortfallReportingInvitation(): Promise<Invitation<import("@endo/exo").Guarded<{
+        makeShortfallReportingInvitation(): Promise<globalThis.Invitation<import("@endo/exo").Guarded<{
             increaseLiquidationShortfall(shortfall: Amount<"nat">): void;
             reduceLiquidationShortfall(reduction: Amount<"nat">): void;
         }>, undefined>>;
+        makeSingleWithdrawalInvitation(): Promise<globalThis.Invitation<any, undefined>>;
+        makeRepeatableWithdrawalInvitation(): Promise<globalThis.Invitation<{
+            invitationMakers: Partial<any>;
+        }, undefined>>;
+        revokeOutstandingWithdrawalInvitations(): void;
     }>>;
     /** @type {GovernedPublicFacet<typeof assetReserveKit.public>} */
     publicFacet: GovernedPublicFacet<import("@endo/exo").Guarded<{
-        makeAddCollateralInvitation(): Promise<Invitation<string, never>>;
+        makeAddCollateralInvitation(): Promise<globalThis.Invitation<string, never>>;
         getPublicTopics(): {
             metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./assetReserveKit.js").MetricsNotification>;
         };
@@ -38,10 +43,16 @@ export type AssetReserveLimitedCreatorFacet = {
     getAllocations: () => Allocation;
     makeShortfallReportingInvitation: () => Promise<Invitation<ShortfallReporter>>;
 };
-export type AssetReservePublicFacet = Awaited<ReturnType<typeof start>>["publicFacet"];
+export type AssetReservePublicFacet = EReturn<typeof start>["publicFacet"];
 /**
  * the creator facet for the governor
  */
-export type AssetReserveCreatorFacet = Awaited<ReturnType<typeof start>>["creatorFacet"];
+export type AssetReserveCreatorFacet = EReturn<typeof start>["creatorFacet"];
+export type ReserveContract = ContractOf<typeof start>;
+import type { ContractMeta } from '@agoric/zoe';
+import type { FeeMintAccess } from '@agoric/zoe';
 import type { Baggage } from '@agoric/vat-data';
+import type { Allocation } from '@agoric/zoe';
+import type { EReturn } from '@endo/far';
+import type { ContractOf } from '@agoric/zoe/src/zoeService/utils.js';
 //# sourceMappingURL=assetReserve.d.ts.map

package/src/reserve/assetReserve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assetReserve.d.ts","sourceRoot":"","sources":["assetReserve.js"],"names":[],"mappings":"AAYA,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAGnC;AAgCK,2BAbI,GAAG,CACT,eAAe,CAAC,EAAE,CAAC,GAAG;IACpB,YAAY,EAAE,CAAC,2BAA2B,CAAC,CAAC;CAC7C,CACF,eACO;IACN,aAAa,EAAE,aAAa,CAAC;IAC7B,sBAAsB,EAAE,UAAU,CAAC;IACnC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAC7B,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;CAChC,WACO,OAAO;IA6Dd,mEAAmE;kBAAxD,oBAAoB;;;;;;;OAAgC;IAE/D,iEAAiE;iBAAtD,mBAAmB;;;;;OAA+B;GAKhE;sCA9FY;IACR,4BAA4B,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACzD,0BAA0B,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CACzD;;kCAgGU,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI;gCAC3B,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI;;;eAK3B,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI;oBACrC,MAAM,UAAU;sCAChB,MAAM,OAAO,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC;;sCAG5C,OAAO,CAAC,UAAU,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC;;;;uCAEjD,OAAO,CAAC,UAAU,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,cAAc,CAAC;6BA1GnC,kBAAkB"}
+{"version":3,"file":"assetReserve.d.ts","sourceRoot":"","sources":["assetReserve.js"],"names":[],"mappings":"AAkBA,yCAAyC;AACzC,mBADW,aAAa,OAAO,KAAK,CAAC,CAGnC;AAgCK,2BAbI,GAAG,CACT,eAAe,CAAC,EAAE,CAAC,GAAG;IACpB,YAAY,EAAE,CAAC,2BAA2B,CAAC,CAAC;CAC7C,CACF,eACO;IACN,aAAa,EAAE,aAAa,CAAC;IAC7B,sBAAsB,EAAE,UAAU,CAAC;IACnC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAC7B,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;CAChC,WACO,OAAO;IAoDd,mEAAmE;kBAAxD,oBAAoB;;;;;;;;;;;;OAAgC;IAE/D,iEAAiE;iBAAtD,mBAAmB;;;;;OAA+B;GAKhE;sCArFY;IACR,4BAA4B,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACzD,0BAA0B,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CACzD;;kCAuFU,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI;gCAC3B,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI;;;eAK3B,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI;oBACrC,MAAM,UAAU;sCAChB,MAAM,OAAO,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC;;sCAG5C,QAAQ,OAAO,KAAK,CAAb,CAAe,aAAa,CAAC;;;;uCAErC,QAAQ,OAAO,KAAK,CAAb,CAAe,cAAc,CAAC;8BAIpC,WAAW,OAAO,KAAK,CAAC;kCAvHkC,aAAa;mCAAb,aAAa;6BAkB1D,kBAAkB;gCAlB2B,aAAa;6BAF3D,WAAW;gCACR,qCAAqC"}

package/src/reserve/assetReserve.js

@@ -8,6 +8,12 @@ import {
 } from '@agoric/zoe/src/contractSupport/index.js';
 import { prepareAssetReserveKit } from './assetReserveKit.js';
 
+/**
+ * @import {EReturn} from '@endo/far';
+ * @import {ContractOf} from '@agoric/zoe/src/zoeService/utils.js';
+ * @import {Allocation, ContractMeta, FeeMintAccess, Installation} from '@agoric/zoe';
+ */
+
 const trace = makeTracer('AR', true);
 
 /** @type {ContractMeta<typeof start>} */
@@ -57,22 +63,13 @@ export const start = async (zcf, privateArgs, baggage) => {
     privateArgs.marshaller,
   );
 
-  /** @type {() => Promise<ZCFMint<'nat'>>} */
-  const takeFeeMint = async () => {
-    if (baggage.has('feeMint')) {
-      return baggage.get('feeMint');
-    }
-
-    const feeMintTemp = await zcf.registerFeeMint(
-      'Fee',
-      privateArgs.feeMintAccess,
-    );
-    baggage.init('feeMint', feeMintTemp);
-    return feeMintTemp;
-  };
-  trace('awaiting takeFeeMint');
-  const feeMint = await takeFeeMint();
   const storageNode = await privateArgs.storageNode;
+
+  trace('awaiting feeMint');
+  const { feeMint } = await provideAll(baggage, {
+    feeMint: () => zcf.registerFeeMint('Fee', privateArgs.feeMintAccess),
+  });
+
   const makeAssetReserveKit = await prepareAssetReserveKit(baggage, {
     feeMint,
     makeRecorderKit,
@@ -127,8 +124,10 @@ harden(start);
  * @property {() => Promise<Invitation<ShortfallReporter>>} makeShortfallReportingInvitation
  */
 
-/** @typedef {Awaited<ReturnType<typeof start>>['publicFacet']} AssetReservePublicFacet */
+/** @typedef {EReturn<typeof start>['publicFacet']} AssetReservePublicFacet */
 /**
- * @typedef {Awaited<ReturnType<typeof start>>['creatorFacet']} AssetReserveCreatorFacet
+ * @typedef {EReturn<typeof start>['creatorFacet']} AssetReserveCreatorFacet
  *   the creator facet for the governor
  */
+
+/** @typedef {ContractOf<typeof start>} ReserveContract */