chore: integrate address hooks, unit tests partially complete

Refs: #8863

Author: anilhelvaci

packages/orchestration/src/examples/swap-anything.contract.js

@@ -1,13 +1,19 @@
 import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
+import { makeTracer } from '@agoric/internal';
 import { E } from '@endo/far';
 import { M } from '@endo/patterns';
+import { decodeAddressHook } from '@agoric/cosmic-proto/address-hooks.js';
 import { prepareChainHubAdmin } from '../exos/chain-hub-admin.js';
 import { withOrchestration } from '../utils/start-helper.js';
 import * as sharedFlows from './shared.flows.js';
-import { swapIt } from './swap-anything.flows.js';
+import { swapIt, swapAnythingViaHook } from './swap-anything.flows.js';
 import { AnyNatAmountShape } from '../typeGuards.js';
 import { registerChainsAndAssets } from '../utils/chain-hub-helper.js';
 
+const trace = makeTracer('SwapAnything.Contract');
+
+const interfaceTODO = undefined;
+
 /**
  * @import {Remote, Vow} from '@agoric/vow';
  * @import {Zone} from '@agoric/zone';
@@ -65,12 +71,90 @@ export const contract = async (
     makeLocalAccount(),
   );
 
-  const swapAnything = orchestrate(
+  const swapAnythingOffer = orchestrate(
     'swapAnything',
     { chainHub, sharedLocalAccountP, log, zoeTools },
     swapIt,
   );
 
+  const swapAnythingAddressHook = orchestrate(
+    'swapAnythingViaHook',
+    {
+      chainHub,
+      sharedLocalAccountP,
+      log,
+    },
+    swapAnythingViaHook,
+  );
+
+  const tap = zone.makeOnce('tapPosition', _key => {
+    console.log('making tap');
+    return zone.exo('tap', interfaceTODO, {
+      /*
+       * @param {import('@agoric/vats').VTransferIBCEvent} event
+       */
+      async receiveUpcall(event) {
+        await null;
+        console.log('receiveUpcall', event);
+        /**
+         * Extract the incoming packet data.
+         *
+         * @type {import('@agoric/cosmic-proto/ibc/applications/transfer/v2/packet.js').FungibleTokenPacketData}
+         */
+        const {
+          amount,
+          denom,
+          receiver: origReceiver,
+        } = JSON.parse(atob(event.packet.data));
+
+        trace({ amount, denom, origReceiver });
+
+        const { baseAddress, query } = decodeAddressHook(origReceiver);
+
+        /**
+         * @type {{
+         *   destAddr: string;
+         *   receiverAddr: string;
+         *   outDenom: string;
+         * }}
+         */
+        // @ts-expect-error
+        const { destAddr, receiverAddr, outDenom } = query;
+
+        trace({
+          baseAddress,
+          destAddr,
+          receiverAddr,
+          outDenom,
+        });
+
+        if (!receiverAddr || !destAddr || !outDenom) return;
+        // Invoke the flow to perform swap and end up at the final destination.
+        return swapAnythingAddressHook(
+          { denom, amount },
+          {
+            destAddr,
+            receiverAddr,
+            outDenom,
+            onFailedDelivery: 'do_nothing',
+            slippage: {
+              slippagePercentage: '20',
+              windowSeconds: 10,
+            },
+          },
+        );
+      },
+    });
+  });
+
+  void vowTools.when(sharedLocalAccountP, async sharedLocalAccount => {
+    sharedLocalAccount.monitorTransfers(tap);
+    const encoded = await E(privateArgs.marshaller).toCapData({
+      sharedLocalAccount: sharedLocalAccount.getAddress(),
+    });
+    void E(privateArgs.storageNode).setValue(JSON.stringify(encoded));
+  });
+
   const publicFacet = zone.exo(
     'Send PF',
     M.interface('Send PF', {
@@ -79,7 +163,7 @@ export const contract = async (
     {
       makeSendInvitation() {
         return zcf.makeInvitation(
-          swapAnything,
+          swapAnythingOffer,
           'swap',
           undefined,
           M.splitRecord({ give: SingleNatAmountRecord }),

packages/orchestration/src/examples/swap-anything.flows.js

@@ -2,7 +2,7 @@ import { NonNullish, makeTracer } from '@agoric/internal';
 import { Fail, makeError, q } from '@endo/errors';
 import { M, mustMatch } from '@endo/patterns';
 
-const trace = makeTracer('SwapAnything');
+const trace = makeTracer('SwapAnything.Flow');
 
 const { entries } = Object;
 
@@ -22,7 +22,7 @@ const { entries } = Object;
  * @import {Vow} from '@agoric/vow';
  * @import {LocalOrchestrationAccountKit} from '../exos/local-orchestration-account.js';
  * @import {ZoeTools} from '../utils/zoe-tools.js';
- * @import {Orchestrator, OrchestrationFlow, ChainHub, ChainInfo, CosmosChainInfo} from '../types.js';
+ * @import {Orchestrator, OrchestrationFlow, ChainHub, CosmosChainInfo} from '../types.js';
  */
 
 const denomForBrand = async (orch, brand) => {
@@ -161,3 +161,66 @@ export const swapIt = async (
   void log(`transfer complete, seat exited`);
 };
 harden(swapIt);
+
+/**
+ * @satisfies {OrchestrationFlow}
+ * @param {Orchestrator} _orch
+ * @param {object} ctx
+ * @param {GuestInterface<ChainHub>} ctx.chainHub
+ * @param {Promise<GuestInterface<LocalOrchestrationAccountKit['holder']>>} ctx.sharedLocalAccountP
+ * @param {GuestOf<(msg: string) => Vow<void>>} ctx.log
+ * @param {{ denom: string; amount: string }} transferInfo
+ * @param {SwapInfo} memoArgs
+ */
+export const swapAnythingViaHook = async (
+  _orch,
+  { chainHub, sharedLocalAccountP, log },
+  { denom, amount },
+  memoArgs,
+) => {
+  mustMatch(
+    memoArgs,
+    M.splitRecord(
+      {
+        destAddr: M.string(),
+        receiverAddr: M.string(),
+        outDenom: M.string(),
+        onFailedDelivery: M.string(),
+        slippage: { slippagePercentage: M.string(), windowSeconds: M.number() },
+      },
+      { nextMemo: M.string() },
+    ),
+  );
+
+  const { receiverAddr, destAddr } = memoArgs;
+  void log(`sending {${amount}} from osmosis to ${receiverAddr}`);
+
+  /**
+   * @type {any} XXX methods returning vows
+   *   https://github.com/Agoric/agoric-sdk/issues/9822
+   */
+  const sharedLocalAccount = await sharedLocalAccountP;
+
+  const [_a, osmosisChainInfo, connection] =
+    await chainHub.getChainsAndConnection('agoric', 'osmosis');
+
+  connection.counterparty || Fail`No IBC connection to Osmosis`;
+
+  void log(`got info for chain: osmosis ${osmosisChainInfo}`);
+  trace(osmosisChainInfo);
+
+  const memo = buildXCSMemo(memoArgs);
+
+  await sharedLocalAccount.transfer(
+    {
+      value: destAddr,
+      encoding: 'bech32',
+      chainId: /** @type {CosmosChainInfo} */ (osmosisChainInfo).chainId,
+    },
+    { denom, value: BigInt(amount) },
+    { memo },
+  );
+
+  return 'Done';
+};
+harden(swapAnythingViaHook);

packages/orchestration/test/examples/swap-anything.test.ts

@@ -1,8 +1,12 @@
 import { test } from '@agoric/zoe/tools/prepare-test-env-ava.js';
 import { setUpZoeForTest } from '@agoric/zoe/tools/setup-zoe.js';
 import { E } from '@endo/far';
+import { eventLoopIteration } from '@agoric/internal/src/testing-utils.js';
+import { encodeAddressHook } from '@agoric/cosmic-proto/address-hooks.js';
+import { NonNullish } from '@agoric/internal';
 import * as contractExports from '../../src/examples/swap-anything.contract.js';
 import { commonSetup } from '../supports.js';
+import { buildVTransferEvent } from '../../tools/ibc-mocks.js';
 
 const contractName = 'swap-anything';
 type StartFn = typeof contractExports.start;
@@ -22,6 +26,7 @@ const bootstrapOrchestration = async t => {
     commonPrivateArgs,
     brands: { bld },
     utils: { inspectLocalBridge, pourPayment, transmitTransferAck },
+    mocks: { transferBridge },
   } = await commonSetup(t);
   const vt = bootstrap.vowTools;
 
@@ -55,6 +60,7 @@ const bootstrapOrchestration = async t => {
     installation,
     storageNode,
     swapKit,
+    transferBridge,
   };
 };
 
@@ -138,4 +144,56 @@ test('swap BLD for Osmo, receiver on Agoric', async t => {
   );
 });
 
+test('trigger osmosis swap from an address hook', async t => {
+  const {
+    bootstrap: { storage },
+    transferBridge,
+    transmitTransferAck,
+    inspectLocalBridge,
+    commonPrivateArgs,
+  } = await bootstrapOrchestration(t);
+  await eventLoopIteration();
+
+  const { sharedLocalAccount } = commonPrivateArgs.marshaller.fromCapData(
+    JSON.parse(
+      NonNullish(storage.data.get('mockChainStorageRoot.swap-anything')),
+    ),
+  );
+
+  t.deepEqual(sharedLocalAccount.value, 'agoric1fakeLCAAddress');
+
+  const memoArgs = buildOfferArgs(config.xcsInformation.rawMsgNoNextMemo);
+  t.log(memoArgs);
+
+  await E(transferBridge).fromBridge(
+    buildVTransferEvent({
+      denom: 'ubld',
+      receiver: encodeAddressHook(
+        'agoric1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqp7zqht',
+        {
+          destAddr: memoArgs.destAddr,
+          receiverAddr: memoArgs.receiverAddr,
+          outDenom: memoArgs.outDenom,
+        },
+      ),
+    }),
+  );
+
+  await transmitTransferAck();
+
+  const history = inspectLocalBridge();
+  t.log(history);
+
+  t.like(
+    history.find(x => x.type === 'VLOCALCHAIN_EXECUTE_TX')?.messages?.[0],
+    {
+      '@type': '/ibc.applications.transfer.v1.MsgTransfer',
+      receiver: memoArgs.destAddr, // XCS contract has to be the one receiving the IBC message
+      sender: 'agoric1fakeLCAAddress',
+      memo: config.xcsInformation.rawMsgNoNextMemo,
+    },
+    'crosschain swap sent',
+  );
+});
+
 test.todo('should throw when Osmosis not connected');