chore: add multichain tests for swapAnything with address hooks

Refs: #8863

Author: anilhelvaci

multichain-testing/test/xcs-swap-anything/swap-anything.test.ts

@@ -1,10 +1,15 @@
 import anyTest from '@endo/ses-ava/prepare-endo.js';
 import type { TestFn } from 'ava';
 import { AmountMath } from '@agoric/ertp';
+import { encodeAddressHook } from '@agoric/cosmic-proto/address-hooks.js';
 import { makeDoOffer } from '../../tools/e2e-tools.js';
 import { commonSetup, type SetupContextWithWallets } from '../support.js';
 import { makeQueryClient } from '../../tools/query.js';
 import starshipChainInfo from '../../starship-chain-info.js';
+import {
+  createFundedWalletAndClient,
+  makeIBCTransferMsg,
+} from '../../tools/ibc-transfer.js';
 
 const test = anyTest as TestFn<SetupContextWithWallets>;
 
@@ -14,6 +19,69 @@ const contractName = 'swapAnything';
 const contractBuilder =
   '../packages/builders/scripts/testing/init-swap-anything.js';
 
+const fundRemote = async (
+  t,
+  destinationChain,
+  denomToTransfer = 'ubld',
+  amount = 100000000n,
+) => {
+  const { retryUntilCondition, useChain } = t.context;
+
+  const { client, address, wallet } = await createFundedWalletAndClient(
+    t.log,
+    destinationChain,
+    useChain,
+  );
+  const balancesResult = await retryUntilCondition(
+    () => client.getAllBalances(address),
+    coins => !!coins?.length,
+    `Faucet balances found for ${address}`,
+  );
+  console.log('Balances:', balancesResult);
+
+  const { client: agoricClient, address: agoricAddress } =
+    await createFundedWalletAndClient(t.log, 'agoric', useChain);
+
+  const balancesResultAg = await retryUntilCondition(
+    () => agoricClient.getAllBalances(agoricAddress),
+    coins => !!coins?.length,
+    `Faucet balances found for ${agoricAddress}`,
+  );
+  console.log('Balances AGORIC:', balancesResultAg);
+
+  const transferArgs = makeIBCTransferMsg(
+    { denom: denomToTransfer, value: amount },
+    { address, chainName: destinationChain },
+    { address: agoricAddress, chainName: 'agoric' },
+    Date.now(),
+    useChain,
+  );
+  console.log('Transfer Args:', transferArgs);
+  // TODO #9200 `sendIbcTokens` does not support `memo`
+  // @ts-expect-error spread argument for concise code
+  const txRes = await agoricClient.sendIbcTokens(...transferArgs);
+  if (txRes && txRes.code !== 0) {
+    console.error(txRes);
+    throw Error(`failed to ibc transfer funds to ${denomToTransfer}`);
+  }
+  const { events: _events, ...txRest } = txRes;
+  console.log(txRest);
+  t.is(txRes.code, 0, `Transaction succeeded`);
+  t.log(`Funds transferred to ${agoricAddress}`);
+
+  await retryUntilCondition(
+    () => client.getAllBalances(address),
+    coins => !!coins?.length,
+    `${denomToTransfer} transferred to ${address}`,
+  );
+
+  return {
+    client,
+    address,
+    wallet,
+  };
+};
+
 test.before(async t => {
   const { setupTestKeys, ...common } = await commonSetup(t);
   const { commonBuilderOpts, deleteTestKeys, startContract } = common;
@@ -24,7 +92,7 @@ test.before(async t => {
   await startContract(contractName, contractBuilder, commonBuilderOpts);
 });
 
-test('BLD for OSMO, receiver on Agoric', async t => {
+test.serial('BLD for OSMO, receiver on Agoric', async t => {
   const {
     wallets,
     provisionSmartWallet,
@@ -103,6 +171,94 @@ test('BLD for OSMO, receiver on Agoric', async t => {
   );
 });
 
+test.serial('address hook - BLD for OSMO, receiver on Agoric', async t => {
+  const { wallets, vstorageClient, retryUntilCondition, useChain } = t.context;
+  const { getRestEndpoint, chain: cosmosChain } = useChain('cosmoshub');
+
+  const { address: cosmosHubAddr, client: cosmosHubClient } = await fundRemote(
+    t,
+    'cosmoshub',
+  );
+
+  const cosmosHubApiUrl = await getRestEndpoint();
+  const cosmosHubQueryClient = makeQueryClient(cosmosHubApiUrl);
+
+  const {
+    transferChannel: { counterPartyChannelId },
+  } = starshipChainInfo.agoric.connections[cosmosChain.chain_id];
+
+  const apiUrl = await useChain('agoric').getRestEndpoint();
+  const queryClient = makeQueryClient(apiUrl);
+
+  const { balances: balancesBefore } = await queryClient.queryBalances(
+    wallets.agoricReceiver,
+  );
+
+  const { hash: bldDenomOnHub } = await cosmosHubQueryClient.queryDenom(
+    `transfer/${counterPartyChannelId}`,
+    'ubld',
+  );
+  t.log({ bldDenomOnHub, counterPartyChannelId });
+
+  const {
+    sharedLocalAccount: { value: baseAddress },
+  } = await vstorageClient.queryData('published.swap-anything');
+  t.log(baseAddress);
+
+  const orcContractReceiverAddress = encodeAddressHook(baseAddress, {
+    destAddr: 'osmo17p9rzwnnfxcjp32un9ug7yhhzgtkhvl9jfksztgw5uh69wac2pgs5yczr8',
+    receiverAddr: wallets.agoricReceiver,
+    outDenom: 'uosmo',
+  });
+
+  const transferArgs = makeIBCTransferMsg(
+    { denom: `ibc/${bldDenomOnHub}`, value: 125n },
+    { address: orcContractReceiverAddress, chainName: 'agoric' },
+    { address: cosmosHubAddr, chainName: 'cosmoshub' },
+    Date.now(),
+    useChain,
+  );
+  console.log('Transfer Args:', transferArgs);
+  // TODO #9200 `sendIbcTokens` does not support `memo`
+  // @ts-expect-error spread argument for concise code
+  const txRes = await cosmosHubClient.sendIbcTokens(...transferArgs);
+  if (txRes && txRes.code !== 0) {
+    console.error(txRes);
+    throw Error(`failed to ibc transfer funds to ibc/${bldDenomOnHub}`);
+  }
+  const { events: _events, ...txRest } = txRes;
+  console.log(txRest);
+  t.is(txRes.code, 0, `Transaction succeeded`);
+  t.log(`Funds transferred to ${orcContractReceiverAddress}`);
+
+  const osmosisChainId = useChain('osmosis').chain.chain_id;
+
+  const {
+    transferChannel: { channelId },
+  } = starshipChainInfo.agoric.connections[osmosisChainId];
+
+  const { balances: agoricReceiverBalances } = await retryUntilCondition(
+    () => queryClient.queryBalances(wallets.agoricReceiver),
+    ({ balances }) => balances.length > balancesBefore.length,
+    'Deposit reflected in localOrchAccount balance',
+  );
+  t.log(agoricReceiverBalances);
+
+  const { hash: expectedHash } = await queryClient.queryDenom(
+    `transfer/${channelId}`,
+    'uosmo',
+  );
+
+  t.log('Expected denom hash:', expectedHash);
+
+  t.regex(agoricReceiverBalances[0]?.denom, /^ibc/);
+  t.is(
+    agoricReceiverBalances[0]?.denom.split('ibc/')[1],
+    expectedHash,
+    'got expected ibc denom hash',
+  );
+});
+
 test.after(async t => {
   const { deleteTestKeys } = t.context;
   deleteTestKeys(accounts);

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

@@ -90,20 +90,23 @@ export const contract = async (
   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);
+        trace('receiveUpcall', event);
+
+        if (event.event !== 'writeAcknowledgement') return;
+        trace('Moving on...');
         /**
          * Extract the incoming packet data.
          *
          * @type {import('@agoric/cosmic-proto/ibc/applications/transfer/v2/packet.js').FungibleTokenPacketData}
          */
         const {
           amount,
-          denom,
+          denom, // transfer/channel-1/ubld, uatom
           receiver: origReceiver,
         } = JSON.parse(atob(event.packet.data));
 
@@ -131,11 +134,11 @@ export const contract = async (
         if (!receiverAddr || !destAddr || !outDenom) return;
         // Invoke the flow to perform swap and end up at the final destination.
         return swapAnythingAddressHook(
-          { denom, amount },
+          { denom: 'ubld', amount },
           {
             destAddr,
             receiverAddr,
-            outDenom,
+            outDenom, // swapOutDenom
             onFailedDelivery: 'do_nothing',
             slippage: {
               slippagePercentage: '20',

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

@@ -101,12 +101,13 @@ export const swapIt = async (
       { nextMemo: M.string() },
     ),
   );
+  void log('Begin swapIt');
 
   const { receiverAddr, destAddr } = offerArgs;
   // NOTE the proposal shape ensures that the `give` is a single asset
   const { give } = seat.getProposal();
   const [[_kw, amt]] = entries(give);
-  void log(`sending {${amt.value}} from osmosis to ${receiverAddr}`);
+  trace(`sending {${amt.value}} from osmosis to ${receiverAddr}`);
   const denom = await denomForBrand(orch, amt.brand);
 
   /**
@@ -123,7 +124,7 @@ export const swapIt = async (
   const recoverFailedTransfer = async e => {
     await withdrawToSeat(sharedLocalAccount, seat, give);
     const errorMsg = `IBC Transfer failed ${q(e)}`;
-    void log(`ERROR: ${errorMsg}`);
+    trace(`ERROR: ${errorMsg}`);
     seat.fail(errorMsg);
     throw makeError(errorMsg);
   };
@@ -133,11 +134,11 @@ export const swapIt = async (
 
   connection.counterparty || Fail`No IBC connection to Osmosis`;
 
-  void log(`got info for chain: osmosis ${osmosisChainInfo}`);
+  trace(`got info for chain: osmosis ${osmosisChainInfo}`);
   trace(osmosisChainInfo);
 
   await localTransfer(seat, sharedLocalAccount, give);
-  void log(`completed transfer to localAccount`);
+  trace(`completed transfer to localAccount`);
 
   try {
     const memo = buildXCSMemo(offerArgs);
@@ -152,13 +153,13 @@ export const swapIt = async (
       { denom, value: amt.value },
       { memo },
     );
-    void log(`completed transfer to ${destAddr}`);
+    trace(`completed transfer to ${destAddr}`);
   } catch (e) {
     return recoverFailedTransfer(e);
   }
 
   seat.exit();
-  void log(`transfer complete, seat exited`);
+  trace(`transfer complete, seat exited`);
 };
 harden(swapIt);
 
@@ -168,13 +169,12 @@ harden(swapIt);
  * @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 },
+  { chainHub, sharedLocalAccountP },
   { denom, amount },
   memoArgs,
 ) => {
@@ -193,7 +193,7 @@ export const swapAnythingViaHook = async (
   );
 
   const { receiverAddr, destAddr } = memoArgs;
-  void log(`sending {${amount}} from osmosis to ${receiverAddr}`);
+  trace(`sending {${amount}} from osmosis to ${receiverAddr}`);
 
   /**
    * @type {any} XXX methods returning vows
@@ -206,7 +206,7 @@ export const swapAnythingViaHook = async (
 
   connection.counterparty || Fail`No IBC connection to Osmosis`;
 
-  void log(`got info for chain: osmosis ${osmosisChainInfo}`);
+  trace(`got info for chain: osmosis ${osmosisChainInfo}`);
   trace(osmosisChainInfo);
 
   const memo = buildXCSMemo(memoArgs);

packages/orchestration/src/proposals/start-swap-anything.js

@@ -10,7 +10,7 @@ import { E } from '@endo/far';
 /**
  * @import {Installation} from '@agoric/zoe/src/zoeService/utils.js';
  * @import {CosmosChainInfo, Denom, DenomDetail} from '@agoric/orchestration';
- * @import {start as StartFn} from '@agoric/orchestration/src/examples/send-anywhere.contract.js';
+ * @import {start as StartFn} from '@agoric/orchestration/src/examples/swap-anything.contract.js';
  */
 
 const trace = makeTracer('StartSA', true);
@@ -75,7 +75,7 @@ export const startSwapAnything = async (
       marshaller,
       orchestrationService: cosmosInterchainService,
       storageNode: E(NonNullish(await chainStorage)).makeChildNode(
-        'send-anywhere',
+        'swap-anything',
       ),
       timerService: chainTimerService,
       chainInfo,

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

@@ -148,7 +148,6 @@ test('trigger osmosis swap from an address hook', async t => {
   const {
     bootstrap: { storage },
     transferBridge,
-    transmitTransferAck,
     inspectLocalBridge,
     commonPrivateArgs,
   } = await bootstrapOrchestration(t);
@@ -167,6 +166,7 @@ test('trigger osmosis swap from an address hook', async t => {
 
   await E(transferBridge).fromBridge(
     buildVTransferEvent({
+      event: 'writeAcknowledgement',
       denom: 'ubld',
       receiver: encodeAddressHook(
         'agoric1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqp7zqht',
@@ -178,8 +178,7 @@ test('trigger osmosis swap from an address hook', async t => {
       ),
     }),
   );
-
-  await transmitTransferAck();
+  await eventLoopIteration();
 
   const history = inspectLocalBridge();
   t.log(history);