WalletFactory survive upgrades and repair outstanding purses and offers

a3p-integration/proposals/a:upgrade-14/package.json

@@ -3,7 +3,11 @@
     "releaseNotes": "https://github.com/Agoric/agoric-sdk/releases/tag/agoric-upgrade-14",
     "sdkImageTag": "unreleased",
     "planName": "agoric-upgrade-14",
-    "upgradeInfo": {},
+    "upgradeInfo": {
+      "coreProposals": [
+        "@agoric/vats/scripts/build-wallet-factory2-upgrade.js"
+      ]
+    },
     "type": "Software Upgrade Proposal"
   },
   "type": "module",

a3p-integration/proposals/a:upgrade-14/post.test.js

@@ -0,0 +1,8 @@
+import test from 'ava';
+import { getIncarnation } from '@agoric/synthetic-chain/src/lib/vat-status.js';
+
+test(`Smart Wallet vat was upgraded`, async t => {
+  const incarnation = await getIncarnation('walletFactory');
+
+  t.is(incarnation, 2);
+});

packages/inter-protocol/test/smartWallet/test-oracle-integration.js

@@ -149,7 +149,7 @@ const acceptInvitation = async (wallet, priceAggregator) => {
 
 let pushPriceCounter = 0;
 /**
- * @param {*} wallet
+ * @param {import('@agoric/smart-wallet/src/smartWallet.js').SmartWallet} wallet
  * @param {string} adminOfferId
  * @param {import('@agoric/inter-protocol/src/price/roundsManager.js').PriceRound} priceRound
  * @returns {Promise<string>} offer id
@@ -322,6 +322,7 @@ test.serial('errors', async t => {
         'In "pushPrice" method of (OracleKit oracle): arg 0: unitPrice: number 1 - Must be a bigint',
     },
   );
+
   await eventLoopIteration();
 
   // Success, round starts

packages/inter-protocol/test/smartWallet/test-psm-integration.js

@@ -93,10 +93,8 @@ test('null swap', async t => {
   t.is(await E.get(getBalanceFor(anchor.brand)).value, 0n);
   t.is(await E.get(getBalanceFor(mintedBrand)).value, 0n);
 
-  t.deepEqual(currents[0].liveOffers, []);
-  t.deepEqual(currents[1].liveOffers, []);
-  t.deepEqual(currents[2].liveOffers, [['nullSwap', offer]]);
-  t.deepEqual(currents[3].liveOffers, []);
+  const found = currents.find(c => c.liveOffers.length > 0);
+  t.deepEqual(found?.liveOffers, [['nullSwap', offer]]);
 });
 
 // we test this direction of swap because wanting anchor would require the PSM to have anchor in it first
@@ -193,11 +191,6 @@ test('want stable (insufficient funds)', async t => {
     'Withdrawal of {"brand":"[Alleged: AUSD brand]","value":"[20000n]"} failed because the purse only contained {"brand":"[Alleged: AUSD brand]","value":"[10000n]"}';
   const status = computedState.offerStatuses.get('insufficientFunds');
   t.is(status?.error, `Error: ${msg}`);
-  /** @type {[PromiseRejectedResult]} */
-  // @ts-expect-error cast
-  const result = status.result;
-  t.is(result[0].status, 'rejected');
-  t.is(result[0].reason.message, msg);
 });
 
 test('govern offerFilter', async t => {
@@ -384,6 +377,8 @@ test('deposit multiple payments to unknown brand', async t => {
   }
 });
 
+// related to recovering dropped Payments
+
 // XXX belongs in smart-wallet package, but needs lots of set-up that's handy here.
 test('recover when some withdrawals succeed and others fail', async t => {
   const { fromEntries } = Object;

packages/smart-wallet/package.json

@@ -17,6 +17,7 @@
   },
   "devDependencies": {
     "@agoric/cosmic-proto": "^0.3.0",
+    "@agoric/vats": "^0.15.2-u13.0",
     "@endo/bundle-source": "2.5.2-upstream-rollup",
     "@endo/captp": "3.1.1",
     "@endo/init": "0.5.56",
@@ -26,6 +27,7 @@
   "dependencies": {
     "@agoric/assert": "^0.6.1-u11wf.0",
     "@agoric/casting": "^0.4.3-u13.0",
+    "@agoric/deploy-script-support": "^0.10.4-u13.0",
     "@agoric/ertp": "^0.16.3-u13.0",
     "@agoric/internal": "^0.4.0-u13.0",
     "@agoric/notifier": "^0.6.3-u13.0",

packages/smart-wallet/src/offerWatcher.js

@@ -0,0 +1,248 @@
+import { E, passStyleOf } from '@endo/far';
+
+import { isUpgradeDisconnection } from '@agoric/internal/src/upgrade-api.js';
+import { prepareExoClassKit, watchPromise } from '@agoric/vat-data';
+import { M } from '@agoric/store';
+import {
+  PaymentPKeywordRecordShape,
+  SeatShape,
+} from '@agoric/zoe/src/typeGuards.js';
+import { AmountShape } from '@agoric/ertp/src/typeGuards.js';
+import { deeplyFulfilledObject, objectMap } from '@agoric/internal';
+
+import { UNPUBLISHED_RESULT } from './offers.js';
+
+/**
+ * @typedef {import('./offers.js').OfferSpec & {
+ *   error?: string,
+ *   numWantsSatisfied?: number
+ *   result?: unknown | typeof import('./offers.js').UNPUBLISHED_RESULT,
+ *   payouts?: AmountKeywordRecord,
+ * }} OfferStatus
+ */
+
+/**
+ * @template {any} T
+ * @typedef {{ onFulfilled: (any) => any, onRejected: (err: Error, seat: any) => void }} OfferPromiseWatcher<T, [UserSeat]
+ */
+
+/**
+ * @typedef {{
+ * resultWatcher: OfferPromiseWatcher<unknown>,
+ * numWantsWatcher: OfferPromiseWatcher<number>,
+ * paymentWatcher: OfferPromiseWatcher<PaymentPKeywordRecord>,
+ * }} OutcomeWatchers
+ */
+
+/**
+ * @param {OutcomeWatchers} watchers
+ * @param {UserSeat} seat
+ */
+const watchForOfferResult = ({ resultWatcher }, seat) => {
+  const p = E(seat).getOfferResult();
+  // @ts-expect-error missing declarations?
+  watchPromise(p, resultWatcher, seat);
+  return p;
+};
+
+/**
+ * @param {OutcomeWatchers} watchers
+ * @param {UserSeat} seat
+ */
+const watchForNumWants = ({ numWantsWatcher }, seat) => {
+  const p = E(seat).numWantsSatisfied();
+  // @ts-expect-error missing declarations?
+  watchPromise(p, numWantsWatcher, seat);
+  return p;
+};
+
+/**
+ * @param {OutcomeWatchers} watchers
+ * @param {UserSeat} seat
+ */
+const watchForPayout = ({ paymentWatcher }, seat) => {
+  const p = E(seat).getPayouts();
+  // @ts-expect-error missing declarations?
+  watchPromise(p, paymentWatcher, seat);
+  return p;
+};
+
+/**
+ * @param {OutcomeWatchers} watchers
+ * @param {UserSeat} seat
+ */
+export const watchOfferOutcomes = (watchers, seat) => {
+  return Promise.all([
+    watchForOfferResult(watchers, seat),
+    watchForNumWants(watchers, seat),
+    watchForPayout(watchers, seat),
+  ]);
+};
+
+const offerWatcherGuard = harden({
+  helper: M.interface('InstanceAdminStorage', {
+    updateStatus: M.call(M.any()).returns(),
+    onNewContinuingOffer: M.call(
+      M.or(M.number(), M.string()),
+      AmountShape,
+      M.any(),
+    )
+      .optional(M.record())
+      .returns(),
+    publishResult: M.call(M.any()).returns(),
+  }),
+  paymentWatcher: M.interface('paymentWatcher', {
+    onFulfilled: M.call(PaymentPKeywordRecordShape, SeatShape).returns(
+      M.promise(),
+    ),
+    onRejected: M.call(M.any(), SeatShape).returns(),
+  }),
+  resultWatcher: M.interface('resultWatcher', {
+    onFulfilled: M.call(M.any(), SeatShape).returns(),
+    onRejected: M.call(M.any(), SeatShape).returns(),
+  }),
+  numWantsWatcher: M.interface('numWantsWatcher', {
+    onFulfilled: M.call(M.number(), SeatShape).returns(),
+    onRejected: M.call(M.any(), SeatShape).returns(),
+  }),
+});
+
+export const prepareOfferWatcher = baggage => {
+  return prepareExoClassKit(
+    baggage,
+    'OfferWatcher',
+    offerWatcherGuard,
+    (walletHelper, deposit, offerSpec, address, iAmount, seatRef) => ({
+      walletHelper,
+      deposit,
+      status: offerSpec,
+      address,
+      invitationAmount: iAmount,
+      seatRef,
+    }),
+    {
+      helper: {
+        updateStatus(offerStatusUpdates) {
+          const { state } = this;
+          state.status = harden({ ...state.status, ...offerStatusUpdates });
+
+          state.walletHelper.updateStatus(state.status);
+        },
+        onNewContinuingOffer(
+          offerId,
+          invitationAmount,
+          invitationMakers,
+          publicSubscribers,
+        ) {
+          const { state } = this;
+
+          void state.walletHelper.addContinuingOffer(
+            offerId,
+            invitationAmount,
+            invitationMakers,
+            publicSubscribers,
+          );
+        },
+
+        publishResult(result) {
+          const { state, facets } = this;
+
+          const passStyle = passStyleOf(result);
+          // someday can we get TS to type narrow based on the passStyleOf result match?
+          switch (passStyle) {
+            case 'bigint':
+            case 'boolean':
+            case 'null':
+            case 'number':
+            case 'string':
+            case 'symbol':
+            case 'undefined':
+              facets.helper.updateStatus({ result });
+              break;
+            case 'copyRecord':
+              if ('invitationMakers' in result) {
+                // save for continuing invitation offer
+
+                void facets.helper.onNewContinuingOffer(
+                  String(state.status.id),
+                  state.invitationAmount,
+                  result.invitationMakers,
+                  result.publicSubscribers,
+                );
+              }
+              facets.helper.updateStatus({ result: UNPUBLISHED_RESULT });
+              break;
+            default:
+              // drop the result
+              facets.helper.updateStatus({ result: UNPUBLISHED_RESULT });
+          }
+        },
+      },
+
+      /** @type {OutcomeWatchers['paymentWatcher']} */
+      paymentWatcher: {
+        async onFulfilled(payouts) {
+          const { state, facets } = this;
+
+          // This will block until all payouts succeed, but user will be updated
+          // since each payout will trigger its corresponding purse notifier.
+          const amountPKeywordRecord = objectMap(payouts, paymentRef =>
+            E.when(paymentRef, payment => state.deposit.receive(payment)),
+          );
+          const amounts = await deeplyFulfilledObject(amountPKeywordRecord);
+          facets.helper.updateStatus({ payouts: amounts });
+        },
+        /**
+         * @param {Error} err
+         * @param {UserSeat} seat
+         */
+        onRejected(err, seat) {
+          const { facets } = this;
+          if (isUpgradeDisconnection(err)) {
+            void watchForPayout(facets, seat);
+          }
+        },
+      },
+
+      /** @type {OutcomeWatchers['resultWatcher']} */
+      resultWatcher: {
+        onFulfilled(result) {
+          const { facets } = this;
+          facets.helper.publishResult(result);
+        },
+        /**
+         * @param {Error} err
+         * @param {UserSeat} seat
+         */
+        onRejected(err, seat) {
+          const { facets } = this;
+          if (isUpgradeDisconnection(err)) {
+            void watchForOfferResult(facets, seat);
+          }
+        },
+      },
+
+      /** @type {OutcomeWatchers['numWantsWatcher']} */
+      numWantsWatcher: {
+        onFulfilled(numSatisfied) {
+          const { facets } = this;
+
+          facets.helper.updateStatus({ numWantsSatisfied: numSatisfied });
+        },
+        /**
+         * @param {Error} err
+         * @param {UserSeat} seat
+         */
+        onRejected(err, seat) {
+          const { facets } = this;
+          if (isUpgradeDisconnection(err)) {
+            void watchForNumWants(facets, seat);
+          }
+        },
+      },
+    },
+  );
+};
+harden(prepareOfferWatcher);
+
+/** @typedef {ReturnType<typeof prepareOfferWatcher>} MakeOfferWatcher */