@agoric/smart-wallet 0.5.3 → 0.5.4-calypso-dev-84eb287.0

package/src/offers.d.ts

@@ -3,46 +3,22 @@
  */
 /**
  * @typedef {{
- *   id: OfferId,
- *   invitationSpec: import('./invitations').InvitationSpec,
- *   proposal: Proposal,
- *   offerArgs?: unknown
+ *   id: OfferId;
+ *   invitationSpec: import('./invitations.js').InvitationSpec;
+ *   proposal: Proposal;
+ *   offerArgs?: any;
  * }} OfferSpec
  */
 /** Value for "result" field when the result can't be published */
 export const UNPUBLISHED_RESULT: "UNPUBLISHED";
-export function makeOfferExecutor({ zoe, depositFacet, invitationIssuer, powers, onStatusChange, onNewContinuingOffer, }: {
-    zoe: ERef<ZoeService>;
-    depositFacet: {
-        receive: (payment: any) => Promise<Amount>;
-    };
-    invitationIssuer: ERef<Issuer<'set'>>;
-    powers: {
-        logger: Pick<Console, 'info' | 'error'>;
-        invitationFromSpec: (spec: import('./invitations').InvitationSpec) => ERef<Invitation>;
-        purseForBrand: (brand: Brand) => Promise<import('./types').RemotePurse>;
-    };
-    onStatusChange: (status: OfferStatus) => void;
-    onNewContinuingOffer: (offerId: string, invitationAmount: Amount<'set'>, invitationMakers: import('./types').RemoteInvitationMakers, publicSubscribers: import('./types').PublicSubscribers | import('@agoric/zoe/src/contractSupport').TopicsRecord) => Promise<void>;
-}): {
-    /**
-     * Take an offer description provided in capData, augment it with payments and call zoe.offer()
-     *
-     * @param {OfferSpec} offerSpec
-     * @param {(seatRef: UserSeat) => void} onSeatCreated
-     * @returns {Promise<void>} when the offer has been sent to Zoe; payouts go into this wallet's purses
-     * @throws if any parts of the offer are determined to be invalid before calling Zoe's `offer()`
-     */
-    executeOffer(offerSpec: OfferSpec, onSeatCreated: (seatRef: UserSeat) => void): Promise<void>;
-};
 export type OfferId = number | string;
 export type OfferSpec = {
     id: OfferId;
-    invitationSpec: import('./invitations').InvitationSpec;
+    invitationSpec: import("./invitations.js").InvitationSpec;
     proposal: Proposal;
-    offerArgs?: unknown;
+    offerArgs?: any;
 };
-export type OfferStatus = import('./offers.js').OfferSpec & {
+export type OfferStatus = OfferSpec & {
     error?: string;
     numWantsSatisfied?: number;
     result?: unknown | typeof UNPUBLISHED_RESULT;

package/src/offers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"offers.d.ts","sourceRoot":"","sources":["offers.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;;;;;;GAOG;AAEH,kEAAkE;AAClE,+CAAgD;AAwBzC;SAVI,KAAK,UAAU,CAAC;;mCACW,QAAQ,MAAM,CAAC;;sBAC1C,KAAK,OAAO,KAAK,CAAC,CAAC;;gBAEnB,KAAK,OAAO,EAAE,MAAM,GAAE,OAAO,CAAC;mCACvB,OAAO,eAAe,EAAE,cAAc,KAAK,KAAK,UAAU,CAAC;+BAC1D,KAAK,KAAK,QAAQ,OAAO,SAAS,EAAE,WAAW,CAAC;;6BAC/C,WAAW,KAAK,IAAI;oCACnB,MAAM,oBAAoB,OAAO,KAAK,CAAC,oBAAoB,OAAO,SAAS,EAAE,sBAAsB,qBAAqB,OAAO,SAAS,EAAE,iBAAiB,GAAG,OAAO,iCAAiC,EAAE,YAAY,KAAM,QAAQ,IAAI,CAAC;;IAaxP;;;;;;;OAOG;4BAJQ,SAAS,2BACC,QAAQ,KAAK,IAAI,GACzB,QAAQ,IAAI,CAAC;EA0I7B;sBA/LY,MAAM,GAAG,MAAM;wBAIf;IACZ,EAAM,EAAE,OAAO,CAAC;IAChB,cAAkB,EAAE,OAAO,eAAe,EAAE,cAAc,CAAC;IAC3D,QAAY,EAAE,QAAQ,CAAC;IACvB,SAAa,CAAC,EAAE,OAAO,CAAA;CACpB;0BAOS,OAAO,aAAa,EAAE,SAAS,GAAG;IAC9C,KAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,MAAQ,CAAC,EAAE,OAAO,GAAG,yBAAyB,CAAC;IAC/C,OAAS,CAAC,EAAE,mBAAmB,CAAC;CAC7B"}
+{"version":3,"file":"offers.d.ts","sourceRoot":"","sources":["offers.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;GAOG;AAEH,kEAAkE;AAClE,+CAAgD;sBAbnC,MAAM,GAAG,MAAM;wBAIf;IACZ,EAAM,EAAE,OAAO,CAAC;IAChB,cAAkB,EAAE,OAAO,kBAAkB,EAAE,cAAc,CAAC;IAC9D,QAAY,EAAE,QAAQ,CAAC;IACvB,SAAa,CAAC,EAAE,GAAG,CAAC;CACjB;0BAOS,SAAS,GAAG;IACxB,KAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,MAAU,CAAC,EAAE,OAAO,GAAG,OAAO,kBAAkB,CAAC;IACjD,OAAW,CAAC,EAAE,mBAAmB,CAAC;CAC/B"}

package/src/offers.js

@@ -1,16 +1,13 @@
-import { E, passStyleOf } from '@endo/far';
-import { makePaymentsHelper } from './payments.js';
-
 /**
  * @typedef {number | string} OfferId
  */
 
 /**
  * @typedef {{
- *   id: OfferId,
- *   invitationSpec: import('./invitations').InvitationSpec,
- *   proposal: Proposal,
- *   offerArgs?: unknown
+ *   id: OfferId;
+ *   invitationSpec: import('./invitations.js').InvitationSpec;
+ *   proposal: Proposal;
+ *   offerArgs?: any;
  * }} OfferSpec
  */
 
@@ -18,180 +15,10 @@ import { makePaymentsHelper } from './payments.js';
 export const UNPUBLISHED_RESULT = 'UNPUBLISHED';
 
 /**
- * @typedef {import('./offers.js').OfferSpec & {
- * error?: string,
- * numWantsSatisfied?: number
- * result?: unknown | typeof UNPUBLISHED_RESULT,
- * payouts?: AmountKeywordRecord,
+ * @typedef {OfferSpec & {
+ *   error?: string;
+ *   numWantsSatisfied?: number;
+ *   result?: unknown | typeof UNPUBLISHED_RESULT;
+ *   payouts?: AmountKeywordRecord;
  * }} OfferStatus
  */
-
-/* eslint-disable jsdoc/check-param-names -- bug(?) with nested objects */
-/**
- * @param {object} opts
- * @param {ERef<ZoeService>} opts.zoe
- * @param {{ receive: (payment: *) => Promise<Amount> }} opts.depositFacet
- * @param {ERef<Issuer<'set'>>} opts.invitationIssuer
- * @param {object} opts.powers
- * @param {Pick<Console, 'info'| 'error'>} opts.powers.logger
- * @param {(spec: import('./invitations').InvitationSpec) => ERef<Invitation>} opts.powers.invitationFromSpec
- * @param {(brand: Brand) => Promise<import('./types').RemotePurse>} opts.powers.purseForBrand
- * @param {(status: OfferStatus) => void} opts.onStatusChange
- * @param {(offerId: string, invitationAmount: Amount<'set'>, invitationMakers: import('./types').RemoteInvitationMakers, publicSubscribers: import('./types').PublicSubscribers | import('@agoric/zoe/src/contractSupport').TopicsRecord ) => Promise<void>} opts.onNewContinuingOffer
- */
-export const makeOfferExecutor = ({
-  zoe,
-  depositFacet,
-  invitationIssuer,
-  powers,
-  onStatusChange,
-  onNewContinuingOffer,
-}) => {
-  const { invitationFromSpec, logger, purseForBrand } = powers;
-
-  return {
-    /**
-     * Take an offer description provided in capData, augment it with payments and call zoe.offer()
-     *
-     * @param {OfferSpec} offerSpec
-     * @param {(seatRef: UserSeat) => void} onSeatCreated
-     * @returns {Promise<void>} when the offer has been sent to Zoe; payouts go into this wallet's purses
-     * @throws if any parts of the offer are determined to be invalid before calling Zoe's `offer()`
-     */
-    async executeOffer(offerSpec, onSeatCreated) {
-      logger.info('starting executeOffer', offerSpec.id);
-
-      const paymentsManager = makePaymentsHelper(purseForBrand, depositFacet);
-
-      /** @type {OfferStatus} */
-      let status = {
-        ...offerSpec,
-      };
-      /** @param {Partial<OfferStatus>} changes */
-      const updateStatus = changes => {
-        status = { ...status, ...changes };
-        onStatusChange(status);
-      };
-
-      /** @type {UserSeat} */
-      let seatRef;
-
-      const tryBody = async () => {
-        // 1. Prepare values and validate synchronously.
-        const { id, invitationSpec, proposal, offerArgs } = offerSpec;
-
-        const invitation = invitationFromSpec(invitationSpec);
-        const invitationAmount = await E(invitationIssuer).getAmountOf(
-          invitation,
-        );
-
-        const paymentKeywordRecord = proposal?.give
-          ? paymentsManager.withdrawGive(proposal.give)
-          : undefined;
-
-        // 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.
-
-        // eslint-disable-next-line @jessie.js/no-nested-await -- unconditional
-        seatRef = await E(zoe).offer(
-          invitation,
-          proposal,
-          paymentKeywordRecord,
-          offerArgs,
-        );
-        logger.info(id, 'seated');
-        onSeatCreated(seatRef);
-
-        const publishResult = E.when(E(seatRef).getOfferResult(), result => {
-          const passStyle = passStyleOf(result);
-          logger.info(id, 'offerResult', passStyle, 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':
-              updateStatus({ result });
-              break;
-            case 'copyRecord':
-              // @ts-expect-error result narrowed by passStyle
-              if ('invitationMakers' in result) {
-                // save for continuing invitation offer
-                void onNewContinuingOffer(
-                  String(id),
-                  invitationAmount,
-                  // @ts-expect-error result narrowed by passStyle
-                  result.invitationMakers,
-                  // @ts-expect-error result narrowed by passStyle
-                  result.publicSubscribers,
-                );
-              }
-              // copyRecord is valid to publish but not safe as it may have private info
-              updateStatus({ result: UNPUBLISHED_RESULT });
-              break;
-            default:
-              // drop the result
-              updateStatus({ result: UNPUBLISHED_RESULT });
-          }
-        });
-
-        const publishWantsSatisfied = E.when(
-          E(seatRef).numWantsSatisfied(),
-          numSatisfied => {
-            logger.info(id, 'numSatisfied', numSatisfied);
-            if (numSatisfied === 0) {
-              updateStatus({ numWantsSatisfied: 0 });
-            }
-            updateStatus({
-              numWantsSatisfied: numSatisfied,
-            });
-          },
-        );
-
-        // This will block until all payouts succeed, but user will be updated
-        // as each payout will trigger its corresponding purse notifier.
-        const publishPayouts = E.when(E(seatRef).getPayouts(), payouts =>
-          paymentsManager.depositPayouts(payouts).then(amountsOrDeferred => {
-            updateStatus({ payouts: amountsOrDeferred });
-          }),
-        );
-
-        // The offer is complete when these promises are resolved.
-        // If any reject then executeOffer rejects and that must be handled.
-        return Promise.all([
-          publishResult,
-          publishWantsSatisfied,
-          publishPayouts,
-        ]);
-      };
-
-      await tryBody().catch(err => {
-        logger.error('OFFER ERROR:', err);
-        // Notify the user
-        updateStatus({ error: err.toString() });
-        // Attempt to recover payments
-        void paymentsManager.tryReclaimingWithdrawnPayments().then(result => {
-          if (result) {
-            updateStatus({ result });
-          }
-        });
-        if (seatRef) {
-          void E(seatRef)
-            .hasExited()
-            .then(hasExited => {
-              if (!hasExited) {
-                void E(seatRef).tryExit();
-              }
-            });
-        }
-        // propagate to caller
-        throw err;
-      });
-    },
-  };
-};
-harden(makeOfferExecutor);

package/src/proposals/upgrade-wallet-factory2-proposal.d.ts

@@ -0,0 +1,23 @@
+export function upgradeWalletFactory({ consume: { walletFactoryStartResult, provisionPoolStartResult, chainStorage, walletBridgeManager: walletBridgeManagerP, }, }: BootstrapPowers & ChainBootstrapSpace, options: {
+    options: {
+        walletRef: VatSourceRef;
+    };
+}): Promise<void>;
+export function getManifestForUpgradeWallet(_powers: any, { walletRef }: {
+    walletRef: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                walletFactoryStartResult: string;
+                provisionPoolStartResult: string;
+                chainStorage: string;
+                walletBridgeManager: string;
+            };
+        };
+    };
+    options: {
+        walletRef: any;
+    };
+};
+//# sourceMappingURL=upgrade-wallet-factory2-proposal.d.ts.map

package/src/proposals/upgrade-wallet-factory2-proposal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade-wallet-factory2-proposal.d.ts","sourceRoot":"","sources":["upgrade-wallet-factory2-proposal.js"],"names":[],"mappings":"AAWO,qKAJI,eAAe,GAAG,mBAAmB,WAE7C;IAA6C,OAAO,EAA5C;QAAE,SAAS,EAAE,YAAY,CAAA;KAAE;CACrC,iBAmCA;AAEM;;;;;;;;;;;;;;;;EAYL"}

package/src/proposals/upgrade-wallet-factory2-proposal.js

@@ -0,0 +1,60 @@
+// @ts-check
+/// <reference types="@agoric/vats/src/core/types-ambient" />
+
+import { E } from '@endo/far';
+import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
+
+/**
+ * @param {BootstrapPowers & ChainBootstrapSpace} powers
+ * @param {object} options
+ * @param {{ walletRef: VatSourceRef }} options.options
+ */
+export const upgradeWalletFactory = async (
+  {
+    consume: {
+      walletFactoryStartResult,
+      provisionPoolStartResult,
+      chainStorage,
+      walletBridgeManager: walletBridgeManagerP,
+    },
+  },
+  options,
+) => {
+  const WALLET_STORAGE_PATH_SEGMENT = 'wallet';
+
+  const { walletRef } = options.options;
+
+  const [walletBridgeManager, walletStorageNode, ppFacets] = await Promise.all([
+    walletBridgeManagerP,
+    makeStorageNodeChild(chainStorage, WALLET_STORAGE_PATH_SEGMENT),
+    provisionPoolStartResult,
+  ]);
+  const walletReviver = await E(ppFacets.creatorFacet).getWalletReviver();
+
+  const privateArgs = {
+    storageNode: walletStorageNode,
+    walletBridgeManager,
+    walletReviver,
+  };
+
+  const { adminFacet } = await walletFactoryStartResult;
+
+  assert(walletRef.bundleID);
+  await E(adminFacet).upgradeContract(walletRef.bundleID, privateArgs);
+
+  console.log(`Successfully upgraded WalletFactory`);
+};
+
+export const getManifestForUpgradeWallet = (_powers, { walletRef }) => ({
+  manifest: {
+    [upgradeWalletFactory.name]: {
+      consume: {
+        walletFactoryStartResult: 'walletFactoryStartResult',
+        provisionPoolStartResult: 'provisionPoolStartResult',
+        chainStorage: 'chainStorage',
+        walletBridgeManager: 'walletBridgeManager',
+      },
+    },
+  },
+  options: { walletRef },
+});

package/src/proposals/upgrade-walletFactory-proposal.d.ts

@@ -0,0 +1,17 @@
+export function upgradeWalletFactory({ consume: { contractKits, governedContractKits, chainStorage, walletBridgeManager: walletBridgeManagerP, }, instance: { consume: { walletFactory: wfInstanceP, provisionPool: ppInstanceP }, }, }: BootstrapPowers, config: {
+    options: {
+        walletFactoryRef: VatSourceRef & {
+            bundleID: string;
+        };
+    };
+}): Promise<void>;
+export function publishAgoricBrandsDisplayInfo({ consume: { agoricNames, board, chainStorage }, }: BootstrapPowers): Promise<void>;
+export function getManifestForUpgrade(_powers: any, { walletFactoryRef }: {
+    walletFactoryRef: any;
+}): {
+    manifest: import("@agoric/vats/src/core/lib-boot").BootstrapManifest;
+    options: {
+        walletFactoryRef: any;
+    };
+};
+//# sourceMappingURL=upgrade-walletFactory-proposal.d.ts.map

package/src/proposals/upgrade-walletFactory-proposal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade-walletFactory-proposal.d.ts","sourceRoot":"","sources":["upgrade-walletFactory-proposal.js"],"names":[],"mappings":"AAoBO,yOAJI,eAAe,UAEvB;IAA0E,OAAO,EAAzE;QAAE,gBAAgB,EAAE,YAAY,GAAG;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE;CACnE,iBAiDA;AAMM,mGAFI,eAAe,iBAwBzB;AAyBM;;;;;;;EAKN"}

package/src/proposals/upgrade-walletFactory-proposal.js

@@ -0,0 +1,127 @@
+// @ts-check
+import { E } from '@endo/far';
+import { makeMarshal } from '@endo/marshal';
+import { allValues } from '@agoric/internal';
+
+console.warn('upgrade-walletFactory-proposal.js module evaluating');
+
+const { Fail } = assert;
+
+// vstorage paths under published.*
+const WALLET_STORAGE_PATH_SEGMENT = 'wallet';
+const BOARD_AUX = 'boardAux';
+
+const marshalData = makeMarshal(_val => Fail`data only`);
+
+/**
+ * @param {BootstrapPowers} powers
+ * @param {object} config
+ * @param {{ walletFactoryRef: VatSourceRef & { bundleID: string } }} config.options
+ */
+export const upgradeWalletFactory = async (
+  {
+    consume: {
+      contractKits,
+      governedContractKits,
+      chainStorage,
+      walletBridgeManager: walletBridgeManagerP,
+    },
+    instance: {
+      consume: { walletFactory: wfInstanceP, provisionPool: ppInstanceP },
+    },
+  },
+  config,
+) => {
+  console.log('upgradeWalletFactory: config', config);
+  const { walletFactoryRef } = config.options;
+
+  // console.log('upgradeWalletFactory: awaiting instances etc.');
+  const { wfInstance, ppInstance, walletBridgeManager, storageNode } =
+    await allValues({
+      wfInstance: wfInstanceP,
+      ppInstance: ppInstanceP,
+      walletBridgeManager: walletBridgeManagerP,
+      // @ts-expect-error chainStorage is only falsy in testing
+      storageNode: E(chainStorage).makeChildNode(WALLET_STORAGE_PATH_SEGMENT),
+    });
+  // console.log('upgradeWalletFactory: awaiting contract kits');
+  const { wfKit, ppKit } = await allValues({
+    wfKit: E(contractKits).get(wfInstance),
+    ppKit: E(governedContractKits).get(ppInstance),
+  });
+  // console.log('upgradeWalletFactory: awaiting walletReviver');
+  const walletReviver = await E(ppKit.creatorFacet).getWalletReviver();
+  const newPrivateArgs = harden({
+    storageNode,
+    walletBridgeManager,
+    walletReviver,
+  });
+
+  console.log(
+    'upgradeWalletFactory: upgrading with newPrivateArgs',
+    newPrivateArgs,
+  );
+  await E(wfKit.adminFacet).upgradeContract(
+    walletFactoryRef.bundleID,
+    newPrivateArgs,
+  );
+  console.log('upgradeWalletFactory: done');
+};
+harden(upgradeWalletFactory);
+
+/**
+ * @param {BootstrapPowers} powers
+ */
+export const publishAgoricBrandsDisplayInfo = async ({
+  consume: { agoricNames, board, chainStorage },
+}) => {
+  // chainStorage type includes undefined, which doesn't apply here.
+  // @ts-expect-error UNTIL https://github.com/Agoric/agoric-sdk/issues/8247
+  const boardAux = E(chainStorage).makeChildNode(BOARD_AUX);
+  const publishBrandInfo = async brand => {
+    const [id, displayInfo, allegedName] = await Promise.all([
+      E(board).getId(brand),
+      E(brand).getDisplayInfo(),
+      E(brand).getAllegedName(),
+    ]);
+    const node = E(boardAux).makeChildNode(id);
+    const aux = marshalData.toCapData(harden({ allegedName, displayInfo }));
+    await E(node).setValue(JSON.stringify(aux));
+  };
+
+  /** @type {ERef<import('@agoric/vats').NameHub>} */
+  const brandHub = E(agoricNames).lookup('brand');
+  const brands = await E(brandHub).values();
+  // tolerate failure; in particular, for the timer brand
+  await Promise.allSettled(brands.map(publishBrandInfo));
+};
+harden(publishAgoricBrandsDisplayInfo);
+
+/** @type {import('@agoric/vats/src/core/lib-boot').BootstrapManifest} */
+const manifest = {
+  [upgradeWalletFactory.name]: {
+    // include rationale for closely-held, high authority capabilities
+    consume: {
+      contractKits: `to upgrade walletFactory using its adminFacet`,
+      governedContractKits:
+        'to get walletReviver from provisionPool.creatorFacet',
+      chainStorage: 'to allow walletFactory to (continue) write to vstorage',
+      walletBridgeManager: 'to handle bridged cosmos SpendAction messages',
+    },
+    // widely-shared, low authority instance handles need no rationale
+    instance: {
+      consume: { walletFactory: true, provisionPool: true },
+    },
+  },
+  [publishAgoricBrandsDisplayInfo.name]: {
+    consume: { agoricNames: true, board: true, chainStorage: true },
+  },
+};
+harden(manifest);
+
+export const getManifestForUpgrade = (_powers, { walletFactoryRef }) => {
+  return harden({
+    manifest,
+    options: { walletFactoryRef },
+  });
+};