@agoric/smart-wallet 0.5.4-u14.1 → 0.5.4-u16.0

package/src/smartWallet.js

@@ -42,149 +42,176 @@ import { shape } from './typeGuards.js';
 import { objectMapStoragePath } from './utils.js';
 import { prepareOfferWatcher, watchOfferOutcomes } from './offerWatcher.js';
 
+/** @import {OfferId, OfferStatus} from './offers.js'; */
+
 const { Fail, quote: q } = assert;
 
 const trace = makeTracer('SmrtWlt');
 
 /**
  * @file Smart wallet module
- *
- * @see {@link ../README.md}}
+ * @see {@link ../README.md} }
  */
 
 /** @typedef {number | string} OfferId */
 
 /**
  * @typedef {{
- *   id: OfferId,
- *   invitationSpec: import('./invitations').InvitationSpec,
- *   proposal: Proposal,
- *   offerArgs?: unknown
+ *   id: OfferId;
+ *   invitationSpec: import('./invitations').InvitationSpec;
+ *   proposal: Proposal;
+ *   offerArgs?: any;
  * }} OfferSpec
  */
 
 /**
  * @typedef {{
- *   logger:  {info: (...args: any[]) => void, error: (...args: any[]) => void},
- *   makeOfferWatcher: import('./offerWatcher.js').MakeOfferWatcher,
- *   invitationFromSpec: ERef<Invitation>,
+ *   logger: {
+ *     info: (...args: any[]) => void;
+ *     error: (...args: any[]) => void;
+ *   };
+ *   makeOfferWatcher: import('./offerWatcher.js').MakeOfferWatcher;
+ *   invitationFromSpec: ERef<Invitation>;
  * }} ExecutorPowers
  */
 
 /**
  * @typedef {{
- *   method: 'executeOffer'
- *   offer: OfferSpec,
+ *   method: 'executeOffer';
+ *   offer: OfferSpec;
  * }} ExecuteOfferAction
  */
 
 /**
  * @typedef {{
- *   method: 'tryExitOffer'
- *   offerId: OfferId,
+ *   method: 'tryExitOffer';
+ *   offerId: OfferId;
  * }} TryExitOfferAction
  */
 
 // Discriminated union. Possible future messages types:
 // maybe suggestIssuer for https://github.com/Agoric/agoric-sdk/issues/6132
 // setting petnames and adding brands for https://github.com/Agoric/agoric-sdk/issues/6126
-/**
- * @typedef { ExecuteOfferAction | TryExitOfferAction } BridgeAction
- */
+/** @typedef {ExecuteOfferAction | TryExitOfferAction} BridgeAction */
 
 /**
- * Purses is an array to support a future requirement of multiple purses per brand.
+ * Purses is an array to support a future requirement of multiple purses per
+ * brand.
  *
- * Each map is encoded as an array of entries because a Map doesn't serialize directly.
- * We also considered having a vstorage key for each offer but for now are sticking with this design.
+ * Each map is encoded as an array of entries because a Map doesn't serialize
+ * directly. We also considered having a vstorage key for each offer but for now
+ * are sticking with this design.
  *
  * Cons
- *    - Reserializes previously written results when a new result is added
- *    - Optimizes reads though writes are on-chain (~100 machines) and reads are off-chain (to 1 machine)
+ *
+ * - Reserializes previously written results when a new result is added
+ * - Optimizes reads though writes are on-chain (~100 machines) and reads are
+ *   off-chain (to 1 machine)
  *
  * Pros
- *    - Reading all offer results happens much more (>100) often than storing a new offer result
- *    - Reserialization and writes are paid in execution gas, whereas reads are not
  *
- * This design should be revisited if ever batch querying across vstorage keys become cheaper or reads be paid.
+ * - Reading all offer results happens much more (>100) often than storing a new
+ *   offer result
+ * - Reserialization and writes are paid in execution gas, whereas reads are not
+ *
+ * This design should be revisited if ever batch querying across vstorage keys
+ * become cheaper or reads be paid.
  *
  * @typedef {{
- *   purses: Array<{brand: Brand, balance: Amount}>,
- *   offerToUsedInvitation: Array<[ offerId: string, usedInvitation: Amount ]>,
- *   offerToPublicSubscriberPaths: Array<[ offerId: string, publicTopics: { [subscriberName: string]: string } ]>,
- *   liveOffers: Array<[OfferId, import('./offers.js').OfferStatus]>,
+ *   purses: { brand: Brand; balance: Amount }[];
+ *   offerToUsedInvitation: [offerId: string, usedInvitation: Amount][];
+ *   offerToPublicSubscriberPaths: [
+ *     offerId: string,
+ *     publicTopics: { [subscriberName: string]: string },
+ *   ][];
+ *   liveOffers: [OfferId, OfferStatus][];
  * }} CurrentWalletRecord
  */
 
 /**
- * @typedef {{ updated: 'offerStatus', status: import('./offers.js').OfferStatus }
+ * @typedef {{ updated: 'offerStatus'; status: OfferStatus }
  *   | { updated: 'balance'; currentAmount: Amount }
- *   | { updated: 'walletAction'; status: { error: string } }
- * } UpdateRecord Record of an update to the state of this wallet.
+ *   | { updated: 'walletAction'; status: { error: string } }} UpdateRecord
+ *   Record of an update to the state of this wallet.
  *
- * Client is responsible for coalescing updates into a current state. See `coalesceUpdates` utility.
+ *   Client is responsible for coalescing updates into a current state. See
+ *   `coalesceUpdates` utility.
  *
- * The reason for this burden on the client is that publishing
- * the full history of offers with each change is untenable.
+ *   The reason for this burden on the client is that publishing the full history
+ *   of offers with each change is untenable.
  *
- * `balance` update supports forward-compatibility for more than one purse per
- * brand. An additional key will be needed to disambiguate. For now the brand in
- * the amount suffices.
+ *   `balance` update supports forward-compatibility for more than one purse per
+ *   brand. An additional key will be needed to disambiguate. For now the brand
+ *   in the amount suffices.
  */
 
 /**
  * @typedef {{
- *   brand: Brand,
- *   displayInfo: DisplayInfo,
- *   issuer: Issuer,
- *   petname: import('./types.js').Petname
+ *   brand: Brand;
+ *   displayInfo: DisplayInfo;
+ *   issuer: Issuer;
+ *   petname: import('./types.js').Petname;
  * }} BrandDescriptor
- * For use by clients to describe brands to users. Includes `displayInfo` to save a remote call.
+ *   For use by clients to describe brands to users. Includes `displayInfo` to
+ *   save a remote call.
  */
 
 /**
  * @typedef {{
- *   address: string,
- *   bank: ERef<import('@agoric/vats/src/vat-bank.js').Bank>,
- *   currentStorageNode: StorageNode,
- *   invitationPurse: Purse<'set'>,
- *   walletStorageNode: StorageNode,
+ *   address: string;
+ *   bank: ERef<import('@agoric/vats/src/vat-bank.js').Bank>;
+ *   currentStorageNode: StorageNode;
+ *   invitationPurse: Purse<'set', InvitationDetails>;
+ *   walletStorageNode: StorageNode;
  * }} UniqueParams
  *
+ *
  * @typedef {Pick<MapStore<Brand, BrandDescriptor>, 'has' | 'get' | 'values'>} BrandDescriptorRegistry
+ *
+ *
  * @typedef {{
- *   agoricNames: ERef<import('@agoric/vats').NameHub>,
- *   registry: BrandDescriptorRegistry,
- *   invitationIssuer: Issuer<'set'>,
- *   invitationBrand: Brand<'set'>,
- *   invitationDisplayInfo: DisplayInfo,
- *   publicMarshaller: Marshaller,
- *   zoe: ERef<ZoeService>,
- *   secretWalletFactoryKey: any,
+ *   agoricNames: ERef<import('@agoric/vats').NameHub>;
+ *   registry: BrandDescriptorRegistry;
+ *   invitationIssuer: Issuer<'set'>;
+ *   invitationBrand: Brand<'set'>;
+ *   invitationDisplayInfo: DisplayInfo;
+ *   publicMarshaller: Marshaller;
+ *   zoe: ERef<ZoeService>;
+ *   secretWalletFactoryKey: any;
  * }} SharedParams
  *
- * @typedef {ImmutableState & MutableState} State
- * - `brandPurses` is precious and closely held. defined as late as possible to reduce its scope.
- * - `offerToInvitationMakers` is precious and closely held.
- * - `offerToPublicSubscriberPaths` is precious and closely held.
- * - `purseBalances` is a cache of what we've received from purses. Held so we can publish all balances on change.
  *
- * @typedef {Readonly<UniqueParams & {
- *   paymentQueues: MapStore<Brand, Array<Payment>>,
- *   offerToInvitationMakers: MapStore<string, import('./types').RemoteInvitationMakers>,
- *   offerToPublicSubscriberPaths: MapStore<string, Record<string, string>>,
- *   offerToUsedInvitation: MapStore<string, Amount<'set'>>,
- *   purseBalances: MapStore<Purse, Amount>,
- *   updateRecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<UpdateRecord>,
- *   currentRecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<CurrentWalletRecord>,
- *   liveOffers: MapStore<OfferId, import('./offers.js').OfferStatus>,
- *   liveOfferSeats: MapStore<OfferId, UserSeat<unknown>>,
- *   liveOfferPayments: MapStore<OfferId, MapStore<Brand, Payment>>,
- * }>} ImmutableState
+ * @typedef {ImmutableState & MutableState} State - `brandPurses` is precious
+ *   and closely held. defined as late as possible to reduce its scope.
+ *
+ *   - `offerToInvitationMakers` is precious and closely held.
+ *   - `offerToPublicSubscriberPaths` is precious and closely held.
+ *   - `purseBalances` is a cache of what we've received from purses. Held so we can
+ *       publish all balances on change.
+ *
+ *
+ * @typedef {Readonly<
+ *   UniqueParams & {
+ *     paymentQueues: MapStore<Brand, Payment[]>;
+ *     offerToInvitationMakers: MapStore<
+ *       string,
+ *       import('./types.js').InvitationMakers
+ *     >;
+ *     offerToPublicSubscriberPaths: MapStore<string, Record<string, string>>;
+ *     offerToUsedInvitation: MapStore<string, Amount<'set'>>;
+ *     purseBalances: MapStore<Purse, Amount>;
+ *     updateRecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<UpdateRecord>;
+ *     currentRecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<CurrentWalletRecord>;
+ *     liveOffers: MapStore<OfferId, OfferStatus>;
+ *     liveOfferSeats: MapStore<OfferId, UserSeat<unknown>>;
+ *     liveOfferPayments: MapStore<OfferId, MapStore<Brand, Payment>>;
+ *   }
+ * >} ImmutableState
+ *
  *
  * @typedef {BrandDescriptor & { purse: Purse }} PurseRecord
- * @typedef {{
- * }} MutableState
+ *
+ * @typedef {{}} MutableState
  */
 
 /**
@@ -296,8 +323,8 @@ export const prepareSmartWallet = (baggage, shared) => {
       (purse, helper) => ({ purse, helper }),
       {
         /**
-         * @param {{ value: Amount, updateCount: bigint | undefined }} updateRecord
-         * @param { Notifier<Amount> } notifier
+         * @param {{ value: Amount; updateCount: bigint | undefined }} updateRecord
+         * @param {Notifier<Amount>} notifier
          * @returns {void}
          */
         onFulfilled(updateRecord, notifier) {
@@ -458,9 +485,10 @@ export const prepareSmartWallet = (baggage, shared) => {
 
   // TODO move to top level so its type can be exported
   /**
-   * Make the durable object to return, but taking some parameters that are awaited by a wrapping function.
-   * This is necessary because the class kit construction helpers, `initState` and `finish` run synchronously
-   * and the child storage node must be awaited until we have durable promises.
+   * Make the durable object to return, but taking some parameters that are
+   * awaited by a wrapping function. This is necessary because the class kit
+   * construction helpers, `initState` and `finish` run synchronously and the
+   * child storage node must be awaited until we have durable promises.
    */
   const makeWalletWithResolvedStorageNodes = prepareExoClassKit(
     baggage,
@@ -548,26 +576,24 @@ export const prepareSmartWallet = (baggage, shared) => {
           // publish purse's balance and changes
           const notifier = await E(purse).getCurrentAmountNotifier();
           const startP = E(notifier).getUpdateSince(undefined);
-          // @ts-expect-error import watchPromise's type is unknown
           watchPromise(startP, handler, notifier);
         },
 
         watchNextBalance(handler, notifier, updateCount) {
           const nextP = E(notifier).getUpdateSince(updateCount);
-          // @ts-expect-error import watchPromise's type is unknown
           watchPromise(nextP, handler, notifier);
         },
 
         /**
-         * Provide a purse given a NameHub of issuers and their
-         * brands.
+         * Provide a purse given a NameHub of issuers and their brands.
          *
-         * We currently support only one NameHub, agoricNames, and
-         * hence one purse per brand. But we store an array of them
-         * to facilitate a transition to decentralized introductions.
+         * We currently support only one NameHub, agoricNames, and hence one
+         * purse per brand. But we store an array of them to facilitate a
+         * transition to decentralized introductions.
          *
          * @param {Brand} brand
-         * @param {ERef<import('@agoric/vats').NameHub>} known - namehub with brand, issuer branches
+         * @param {ERef<import('@agoric/vats').NameHub>} known - namehub with
+         *   brand, issuer branches
          * @returns {Promise<Purse | undefined>} undefined if brand is not known
          */
         async getPurseIfKnownBrand(brand, known) {
@@ -670,9 +696,8 @@ export const prepareSmartWallet = (baggage, shared) => {
                 const tempInvitation = invitationFromSpec(
                   offerSpec.invitationSpec,
                 );
-                invitationAmount = await E(invitationIssuer).getAmountOf(
-                  tempInvitation,
-                );
+                invitationAmount =
+                  await E(invitationIssuer).getAmountOf(tempInvitation);
                 void E(invitationIssuer).burn(tempInvitation);
               }
 
@@ -709,7 +734,7 @@ export const prepareSmartWallet = (baggage, shared) => {
           void helper.watchPurse(invitationPurse);
         },
 
-        /** @param {import('./offers.js').OfferStatus} offerStatus */
+        /** @param {OfferStatus} offerStatus */
         updateStatus(offerStatus) {
           const { state, facets } = this;
           facets.helper.logWalletInfo('offerStatus', offerStatus);
@@ -736,6 +761,13 @@ export const prepareSmartWallet = (baggage, shared) => {
             }
           }
         },
+
+        /**
+         * @param {string} offerId
+         * @param {Amount<'set'>} invitationAmount
+         * @param {import('./types.js').InvitationMakers} invitationMakers
+         * @param {import('./types.js').PublicSubscribers} publicSubscribers
+         */
         async addContinuingOffer(
           offerId,
           invitationAmount,
@@ -763,7 +795,6 @@ export const prepareSmartWallet = (baggage, shared) => {
           const { registry, invitationBrand } = shared;
 
           if (registry.has(brand)) {
-            // @ts-expect-error virtual purse
             return E(state.bank).getPurse(brand);
           } else if (invitationBrand === brand) {
             return state.invitationPurse;
@@ -809,7 +840,8 @@ export const prepareSmartWallet = (baggage, shared) => {
         },
       },
       /**
-       * Similar to {DepositFacet} but async because it has to look up the purse.
+       * Similar to {DepositFacet} but async because it has to look up the
+       * purse.
        */
       deposit: {
         /**
@@ -819,7 +851,8 @@ export const prepareSmartWallet = (baggage, shared) => {
          *
          * @param {Payment} payment
          * @returns {Promise<Amount>}
-         * @throws if there's not yet a purse, though the payment is held to try again when there is
+         * @throws if there's not yet a purse, though the payment is held to try
+         *   again when there is
          */
         async receive(payment) {
           const {
@@ -834,6 +867,7 @@ export const prepareSmartWallet = (baggage, shared) => {
           // When there is a purse deposit into it
           if (registry.has(brand)) {
             const purse = E(bank).getPurse(brand);
+            // @ts-expect-error narrow assetKind to 'nat'
             return E(purse).deposit(payment);
           } else if (invitationBrand === brand) {
             // @ts-expect-error narrow assetKind to 'set'
@@ -857,9 +891,11 @@ export const prepareSmartWallet = (baggage, shared) => {
 
       payments: {
         /**
-         * Withdraw the offered amount from the appropriate purse of this wallet.
+         * Withdraw the offered amount from the appropriate purse of this
+         * wallet.
          *
-         * Save its amount in liveOfferPayments in case we need to reclaim the payment.
+         * Save its amount in liveOfferPayments in case we need to reclaim the
+         * payment.
          *
          * @param {AmountKeywordRecord} give
          * @param {OfferId} offerId
@@ -899,10 +935,11 @@ export const prepareSmartWallet = (baggage, shared) => {
         },
 
         /**
-         * Find the live payments for the offer and deposit them back in the appropriate purses.
+         * Find the live payments for the offer and deposit them back in the
+         * appropriate purses.
          *
          * @param {OfferId} offerId
-         * @returns {Promise<void>}
+         * @returns {Promise<Amount[]>}
          */
         async tryReclaimingWithdrawnPayments(offerId) {
           const { facets } = this;
@@ -913,8 +950,9 @@ export const prepareSmartWallet = (baggage, shared) => {
           if (liveOfferPayments.has(offerId)) {
             const brandPaymentRecord = liveOfferPayments.get(offerId);
             if (!brandPaymentRecord) {
-              return;
+              return [];
             }
+            const out = [];
             // Use allSettled to ensure we attempt all the deposits, regardless of
             // individual rejections.
             await Promise.allSettled(
@@ -924,20 +962,29 @@ export const prepareSmartWallet = (baggage, shared) => {
                 const purseP = facets.helper.purseForBrand(b);
 
                 // Now send it back to the purse.
-                return E(purseP).deposit(p);
+                return E(purseP)
+                  .deposit(p)
+                  .then(amt => {
+                    out.push(amt);
+                  });
               }),
             );
+            return harden(out);
           }
+          return [];
         },
       },
 
       offers: {
         /**
-         * Take an offer description provided in capData, augment it with payments and call zoe.offer()
+         * Take an offer description provided in capData, augment it with
+         * payments and call zoe.offer()
          *
          * @param {OfferSpec} offerSpec
-         * @returns {Promise<void>} after the offer has been both seated and exited by Zoe.
-         * @throws if any parts of the offer can be determined synchronously to be invalid
+         * @returns {Promise<void>} after the offer has been both seated and
+         *   exited by Zoe.
+         * @throws if any parts of the offer can be determined synchronously to
+         *   be invalid
          */
         async executeOffer(offerSpec) {
           const { facets, state } = this;
@@ -949,6 +996,7 @@ export const prepareSmartWallet = (baggage, shared) => {
 
           await null;
 
+          /** @type {UserSeat} */
           let seatRef;
           let watcher;
           try {
@@ -967,23 +1015,23 @@ export const prepareSmartWallet = (baggage, shared) => {
 
             const invitation = invitationFromSpec(offerSpec.invitationSpec);
 
-            const [paymentKeywordRecord, invitationAmount] = await Promise.all([
-              proposal?.give &&
-                deeplyFulfilledObject(
-                  facets.payments.withdrawGive(proposal.give, offerSpec.id),
-                ),
-              E(invitationIssuer).getAmountOf(invitation),
-            ]);
+            const invitationAmount =
+              await E(invitationIssuer).getAmountOf(invitation);
 
             // 2. Begin executing offer
             // No explicit signal to user that we reached here but if anything above
             // failed they'd get an 'error' status update.
 
-            /** @type {UserSeat} */
+            const withdrawnPayments =
+              proposal?.give &&
+              (await deeplyFulfilledObject(
+                facets.payments.withdrawGive(proposal.give, offerSpec.id),
+              ));
+
             seatRef = await E(zoe).offer(
               invitation,
               proposal,
-              paymentKeywordRecord,
+              withdrawnPayments,
               offerSpec.offerArgs,
             );
             facets.helper.logWalletInfo(offerSpec.id, 'seated');
@@ -1005,19 +1053,19 @@ export const prepareSmartWallet = (baggage, shared) => {
 
             // await so that any errors are caught and handled below
             await watchOfferOutcomes(watcher, seatRef);
-          } catch (err) {
+          } catch (reason) {
             // This block only runs if the block above fails during one vat incarnation.
-            facets.helper.logWalletError('IMMEDIATE OFFER ERROR:', err);
+            facets.helper.logWalletError('IMMEDIATE OFFER ERROR:', reason);
 
             // Update status to observers
-            if (err.upgradeMessage === 'vat upgraded') {
+            if (isUpgradeDisconnection(reason)) {
               // The offer watchers will reconnect. Don't reclaim or exit
               return;
             } else if (watcher) {
               // The watcher's onRejected will updateStatus()
             } else {
               facets.helper.updateStatus({
-                error: err.toString(),
+                error: reason.toString(),
                 ...offerSpec,
               });
             }
@@ -1036,7 +1084,7 @@ export const prepareSmartWallet = (baggage, shared) => {
 
             // XXX tests rely on throwing immediate errors, not covering the
             // error handling in the event the failure is after an upgrade
-            throw err;
+            throw reason;
           }
         },
         /**
@@ -1047,15 +1095,30 @@ export const prepareSmartWallet = (baggage, shared) => {
          * @throws if the seat can't be found or E(seatRef).tryExit() fails.
          */
         async tryExitOffer(offerId) {
+          const { facets } = this;
+          const amts = await facets.payments
+            .tryReclaimingWithdrawnPayments(offerId)
+            .catch(e => {
+              facets.helper.logWalletError(
+                'recovery failed reclaiming payments',
+                e,
+              );
+              return [];
+            });
+          if (amts.length > 0) {
+            facets.helper.logWalletInfo('reclaimed', amts, 'from', offerId);
+          }
           const seatRef = this.state.liveOfferSeats.get(offerId);
           await E(seatRef).tryExit();
         },
       },
       self: {
         /**
-         * Umarshals the actionCapData and delegates to the appropriate action handler.
+         * Umarshals the actionCapData and delegates to the appropriate action
+         * handler.
          *
-         * @param {import('@endo/marshal').CapData<string>} actionCapData of type BridgeAction
+         * @param {import('@endo/marshal').CapData<string | null>} actionCapData
+         *   of type BridgeAction
          * @param {boolean} [canSpend]
          * @returns {Promise<void>}
          */
@@ -1171,7 +1234,12 @@ export const prepareSmartWallet = (baggage, shared) => {
   );
 
   /**
-   * @param {Omit<UniqueParams, 'currentStorageNode' | 'walletStorageNode'> & {walletStorageNode: ERef<StorageNode>}} uniqueWithoutChildNodes
+   * @param {Omit<
+   *   UniqueParams,
+   *   'currentStorageNode' | 'walletStorageNode'
+   * > & {
+   *   walletStorageNode: ERef<StorageNode>;
+   * }} uniqueWithoutChildNodes
    */
   const makeSmartWallet = async uniqueWithoutChildNodes => {
     const [walletStorageNode, currentStorageNode] = await Promise.all([

package/src/typeGuards.d.ts

@@ -1,4 +1,4 @@
 export namespace shape {
-    const WalletBridgeMsg: import("@endo/patterns").Matcher;
+    let WalletBridgeMsg: import("@endo/patterns").Matcher;
 }
 //# sourceMappingURL=typeGuards.d.ts.map

package/src/types.d.ts

@@ -5,10 +5,11 @@
  * Downside is it can't reference any ambient types, which most of agoric-sdk type are presently.
  */
 
-import type { ERef, FarRef } from '@endo/far';
+import type { ERef } from '@endo/far';
 import type { CapData } from '@endo/marshal';
-import type { MsgWalletSpendAction } from '@agoric/cosmic-proto/swingset/msgs';
+import type { agoric } from '@agoric/cosmic-proto';
 import type { AgoricNamesRemotes } from '@agoric/vats/tools/board-utils.js';
+import type { StoredFacet } from '@agoric/internal/src/lib-chainStorage.js';
 import type { OfferSpec } from './offers.js';
 
 declare const CapDataShape: unique symbol;
@@ -21,33 +22,33 @@ declare const CapDataShape: unique symbol;
  */
 export type Petname = string | string[];
 
-export type RemotePurse<T = unknown> = FarRef<Purse<T>>;
-
-export type RemoteInvitationMakers = FarRef<
-  Record<string, (...args: any[]) => Promise<Invitation>>
+export type InvitationMakers = Record<
+  string,
+  (...args: any[]) => Promise<Invitation>
 >;
 
 export type PublicSubscribers = Record<string, ERef<StoredFacet>>;
 
+export interface ContinuingOfferResult {
+  invitationMakers: InvitationMakers;
+  publicSubscribers: PublicSubscribers;
+}
+
 export type Cell<T> = {
   get: () => T;
   set(val: T): void;
 };
 
-export type BridgeActionCapData = WalletCapData<
-  import('./smartWallet.js').BridgeAction
->;
-
 /**
  * Defined by walletAction struct in msg_server.go
  *
- * @see {MsgWalletSpendAction} and walletSpendAction in msg_server.go
+ * @see {agoric.swingset.MsgWalletAction} and walletSpendAction in msg_server.go
  */
 export type WalletActionMsg = {
   type: 'WALLET_ACTION';
   /** base64 of Uint8Array of bech32 data  */
   owner: string;
-  /** JSON of BridgeActionCapData */
+  /** JSON of marshalled BridgeAction */
   action: string;
   blockHeight: unknown; // int64
   blockTime: unknown; // int64
@@ -56,7 +57,7 @@ export type WalletActionMsg = {
 /**
  * Defined by walletSpendAction struct in msg_server.go
  *
- * @see {MsgWalletSpendAction} and walletSpendAction in msg_server.go
+ * @see {agoric.swingset.MsgWalletSpendAction} and walletSpendAction in msg_server.go
  */
 export type WalletSpendActionMsg = {
   type: 'WALLET_SPEND_ACTION';