feat(smartWallet): invoke offerResult without involving Zoe (#11672)

refs:
 - #8733
 - #11256

## Description

 - add a `nameHub` and `nameAdmin` to state of each offer result
 - add `spec.after.saveAs` option in `OfferSpec` to save an offer result
- add `invokeItem` method in `BridgeAction` that uses a format somewhat
like `callPipe`

DRAFT until the TODOs below are addressed.

### Security / Scaling Considerations

This is intended to serve as an efficient, straightforward alternative
to continuing offers for the (common) case when no asset exchange is
happening. The motivating usage is ymax oracles (it facitiliates
optimizing Fast USDC oracles too).

TODO:
- [x] think thru allowing everyone, not just oracles, to use
`invokeItem`. Without a suitable invitation, it's useless; but what
about griefing?
- [x] `callPipe` was allowed only on `agoricContract`; are we ready to
drop that limitation?
- [x] length limit was 3; this is currently unlimited; we haven't found
motivation to extend past 3, have we?

### Documentation / Testing Considerations

One happy path test shows that the feature works and how to use it.

TODO
 - [x] test failure modes
- [x] the test uses bundled code, which doesn't mix well with coverage
tools. Invest in testBundle tests for smartWallet?

### Upgrade Considerations

TODO:
- [ ] figure out upgrade implications of adding to smartWallet exo state

Author: mhofman

packages/boot/package.json

@@ -49,6 +49,7 @@
     "@endo/far": "^1.1.14",
     "@endo/init": "^1.1.12",
     "@endo/marshal": "^1.8.0",
+    "@endo/patterns": "^1.7.0",
     "@endo/promise-kit": "^1.1.13",
     "@endo/stream": "^1.2.13",
     "import-meta-resolve": "^4.1.0",
@@ -63,7 +64,6 @@
     "@agoric/store": "workspace:*",
     "@agoric/swingset-liveslots": "workspace:*",
     "@endo/base64": "^1.0.12",
-    "@endo/patterns": "^1.7.0",
     "ava": "^5.3.0",
     "c8": "^10.1.3",
     "ts-blank-space": "^0.6.1"

packages/boot/test/bootstrapTests/wallet-fun.test.ts

@@ -0,0 +1,137 @@
+/** @file use capabilities in smart wallet without offers */
+import { test as anyTest } from '@agoric/zoe/tools/prepare-test-env-ava.js';
+
+import { eventLoopIteration } from '@agoric/internal/src/testing-utils.js';
+import type { CurrentWalletRecord } from '@agoric/smart-wallet/src/smartWallet.js';
+import { start as startPriceContract } from '@agoric/smart-wallet/test/wallet-fun.contract.js';
+import type { NameHub } from '@agoric/vats';
+import type { IssuerKeywordRecord } from '@agoric/zoe';
+import type { Installation } from '@agoric/zoe/src/zoeService/utils';
+import bundleSource from '@endo/bundle-source';
+import type { ExecutionContext, TestFn } from 'ava';
+import { createRequire } from 'node:module';
+import {
+  makeWalletFactoryContext,
+  type WalletFactoryTestContext as TC,
+} from './walletFactory.ts';
+
+const nodeRequire = createRequire(import.meta.url);
+
+const test = anyTest as TestFn<TC>;
+
+test.before(async t => {
+  t.context = await makeWalletFactoryContext(t);
+});
+test.after.always(t => {
+  return t.context.shutdown && t.context.shutdown();
+});
+
+const startContract = async <SF>(
+  t: ExecutionContext<TC>,
+  _startFn: SF,
+  specifier: string,
+  name?: string,
+  issuers?: IssuerKeywordRecord,
+) => {
+  const { runUtils, refreshAgoricNamesRemotes } = t.context;
+  const { EV } = runUtils;
+  const zoe = await EV.vat('bootstrap').consumeItem('zoe');
+  const bundle = await bundleSource(nodeRequire.resolve(specifier));
+
+  const installation: Installation<SF> = await EV(zoe).install(bundle);
+  const started = await EV(zoe).startInstance(installation, issuers);
+  t.log('started', specifier, Object.keys(started));
+
+  if (name) {
+    const agoricNamesAdmin =
+      await EV.vat('bootstrap').consumeItem('agoricNamesAdmin');
+    const instanceAdmin = await EV(agoricNamesAdmin).lookupAdmin('instance');
+    await EV(instanceAdmin).update(name, started.instance);
+    refreshAgoricNamesRemotes();
+  }
+  return started;
+};
+
+const showInvitationBalance = (addr: string, r: CurrentWalletRecord) => [
+  addr,
+  'has invitations',
+  r.purses.flatMap(p => p.balance.value),
+];
+
+test('use offer result without zoe', async t => {
+  const { walletFactoryDriver, agoricNamesRemotes } = t.context;
+
+  const makeCoreCtx = (addr: string) => {
+    const start = async () => {
+      const { EV } = t.context.runUtils;
+      const namesByAddress =
+        await EV.vat('bootstrap').consumeItem('namesByAddress');
+
+      const started = await startContract(
+        t,
+        startPriceContract,
+        './wallet-fun.contract.js',
+        'walletFun',
+      );
+      const toSetPrices = await EV(started.creatorFacet).makeAdminInvitation();
+      const df = await EV(namesByAddress).lookup(addr, 'depositFacet');
+      const rxd = EV(df).receive(toSetPrices);
+      const getPrices = async () => {
+        const p = await EV(started.publicFacet).getPrices();
+        return p;
+      };
+      return harden({ getReceived: () => rxd, getPrices });
+    };
+
+    return harden({ start });
+  };
+
+  // client-side presence
+  const addr = 'agoric1admin';
+  const wd = await walletFactoryDriver.provideSmartWallet(addr);
+
+  const makePriceOracle = () => {
+    const redeemInvitation = async () => {
+      const { walletFun } = agoricNamesRemotes.instance;
+      t.truthy(walletFun);
+
+      t.log(...showInvitationBalance(addr, wd.getCurrentWalletRecord()));
+
+      await wd.executeOffer({
+        id: 'redeemInvitation',
+        invitationSpec: {
+          source: 'purse',
+          description: 'admin',
+          instance: walletFun,
+        },
+        proposal: {},
+        after: { saveAs: 'priceSetter' },
+      });
+      t.log('redeemInvitation last update', wd.getLatestUpdateRecord());
+    };
+
+    const useOfferResult = () =>
+      wd.invokeItem('priceSetter', {
+        method: 'setPrice',
+        args: [100n],
+      });
+
+    return harden({ redeemInvitation, useOfferResult });
+  };
+
+  const core = makeCoreCtx(addr);
+  const { getPrices, getReceived } = await core.start();
+
+  const oracle = makePriceOracle();
+  await oracle.redeemInvitation();
+  await getReceived();
+  const initialPrices = await getPrices();
+  t.log({ initialPrices });
+  t.deepEqual(initialPrices, [0n], 'initial price');
+
+  await oracle.useOfferResult();
+  await eventLoopIteration();
+  const actual = await getPrices();
+  t.log('prices after', actual);
+  t.deepEqual(actual, [100n], 'updated price');
+});

packages/boot/tools/drivers.ts

@@ -13,8 +13,12 @@ import {
 } from '@agoric/internal/src/storage-test-utils.js';
 import { Fail } from '@endo/errors';
 
-import type { OfferSpec } from '@agoric/smart-wallet/src/offers.js';
 import type {
+  OfferResultStep,
+  OfferSpec,
+} from '@agoric/smart-wallet/src/offers.js';
+import type {
+  BridgeAction,
   CurrentWalletRecord,
   SmartWallet,
   UpdateRecord,
@@ -58,6 +62,15 @@ export const makeWalletFactoryDriver = async (
     isNew,
     getAddress: () => walletAddress,
 
+    invokeItem(name: string, ...steps: OfferResultStep[]): Promise<void> {
+      const action: BridgeAction = harden({
+        method: 'invokeItem',
+        name,
+        steps,
+      });
+      const offerCapData = marshaller.toCapData(action);
+      return EV(walletPresence).handleBridgeAction(offerCapData, false);
+    },
     executeOffer(offer: OfferSpec): Promise<void> {
       const offerCapData = myMarshaller.toCapData(
         harden({

packages/smart-wallet/package.json

@@ -10,6 +10,7 @@
     "prepack": "yarn run -T tsc --build tsconfig.build.json",
     "postpack": "git clean -f '*.d.ts*' '*.tsbuildinfo'",
     "test": "ava",
+    "test:c8": "c8 --all $C8_OPTIONS ava",
     "test:xs": "exit 0",
     "lint": "yarn run -T run-s --continue-on-error 'lint:*'",
     "lint-fix": "yarn lint:eslint --fix",
@@ -41,6 +42,7 @@
     "@endo/far": "^1.1.14",
     "@endo/marshal": "^1.8.0",
     "@endo/nat": "^5.1.3",
+    "@endo/patterns": "^1.7.0",
     "@endo/promise-kit": "^1.1.13"
   },
   "files": [

packages/smart-wallet/src/offerWatcher.js

@@ -274,7 +274,20 @@ export const prepareOfferWatcher = (baggage, vowTools) => {
       resultWatcher: {
         onFulfilled(result) {
           const { facets } = this;
-          facets.helper.publishResult(result);
+          const { walletHelper } = this.state;
+          const { after } = this.state.status;
+          if (after) {
+            if (after.saveAs) {
+              const { saveAs: name } = after;
+              // Note: result is passable and storable since it was received from another vat
+              walletHelper.saveOfferResult(name, result);
+              facets.helper.publishResult(
+                harden({ [name]: { passStyle: passStyleOf(result) } }),
+              );
+            }
+          } else {
+            facets.helper.publishResult(result);
+          }
         },
         /**
          * If promise disconnected, watch again. Or if there's an Error, handle

packages/smart-wallet/src/offers.js

@@ -6,12 +6,23 @@
  * @typedef {number | string} OfferId
  */
 
+// TODO: change saveAs to be direct part of step / offerSpec
+// TODO: accept missing/undefined method name for function invocation
+// TODO: change from multi step to a single InvokeSpec
+
+/**
+ * @typedef {{ method: string; args: unknown[] } | { saveAs: string }} OfferResultStep
+ */
+
 /**
  * @typedef {{
  *   id: OfferId;
  *   invitationSpec: import('./invitations.js').InvitationSpec;
  *   proposal: Proposal;
  *   offerArgs?: any;
+ *   after?: {
+ *     saveAs?: string;
+ *   };
  * }} OfferSpec
  */