chore: unit test for happy path

anilhelvaci · anilhelvaci · commit 9da7798ecd11 · 2025-04-28T14:08:07.000+03:00
Refs: #8863
diff --git a/packages/orchestration/src/examples/swap-anything.flows.js b/packages/orchestration/src/examples/swap-anything.flows.js
@@ -1,22 +1,28 @@
 import { NonNullish, makeTracer } from '@agoric/internal';
 import { Fail, makeError, q } from '@endo/errors';
 import { M, mustMatch } from '@endo/patterns';
-import { RatioShape } from '@agoric/ertp';
 
 const trace = makeTracer('SwapAnything');
 
 const { entries } = Object;
 
 /**
+ * @typedef {{
+ *   destAddr: string;
+ *   receiverAddr: string;
+ *   outDenom: Denom;
+ *   slippage: { slippagePercentage: string; windowSeconds: number };
+ *   onFailedDelivery: string;
+ *   nextMemo?: string;
+ * }} SwapInfo
+ *
  * @import {GuestInterface, GuestOf} from '@agoric/async-flow';
- * @import {Denom, DenomDetail} from '@agoric/orchestration';
- * @import {ZCF, ZCFSeat} from '@agoric/zoe';
- * @import {Brand} from '@agoric/ertp';
+ * @import {Denom} from '@agoric/orchestration';
+ * @import {ZCFSeat} from '@agoric/zoe';
  * @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} from '../types.js';
- * @import {AccountIdArg} from '../orchestration-api.ts';
+ * @import {Orchestrator, OrchestrationFlow, ChainHub, ChainInfo, CosmosChainInfo} from '../types.js';
  */
 
 const denomForBrand = async (orch, brand) => {
@@ -29,6 +35,34 @@ const denomForBrand = async (orch, brand) => {
   return denom;
 };
 
+/**
+ * @param {SwapInfo} swapInfo
+ * @returns {string}
+ */
+const buildXCSMemo = swapInfo => {
+  const memo = {
+    wasm: {
+      contract: swapInfo.destAddr,
+      msg: {
+        osmosis_swap: {
+          output_denom: swapInfo.outDenom,
+          slippage: {
+            twap: {
+              window_seconds: swapInfo.slippage.windowSeconds,
+              slippage_percentage: swapInfo.slippage.slippagePercentage,
+            },
+          },
+          receiver: swapInfo.receiverAddr,
+          on_failed_delivery: swapInfo.onFailedDelivery,
+          nextMemo: swapInfo.nextMemo,
+        },
+      },
+    },
+  };
+
+  return JSON.stringify(memo);
+};
+
 /**
  * @satisfies {OrchestrationFlow}
  * @param {Orchestrator} orch
@@ -38,14 +72,7 @@ const denomForBrand = async (orch, brand) => {
  * @param {GuestInterface<ZoeTools>} ctx.zoeTools
  * @param {GuestOf<(msg: string) => Vow<void>>} ctx.log
  * @param {ZCFSeat} seat
- * @param {{
- *   destAddr: string;
- *   receiverAddr: string;
- *   outDenom: Denom;
- *   slippage: { slippageRatio: Ratio; windowSeconds: bigint };
- *   onFailedDelivery: string;
- *   nextMemo?: string;
- * }} offerArgs
+ * @param {SwapInfo} offerArgs
  */
 
 // Given USDC, swap to desired token with slippage
@@ -61,15 +88,6 @@ export const swapIt = async (
   seat,
   offerArgs,
 ) => {
-  //   offerArgs,
-  //   harden({
-  //     destAddr: M.string(),
-  //     receiverAddr: M.string(),
-  //     outDenom: M.string(),
-  //     onFailedDelivery: M.string(),
-  //     slippage: { slippageRatio: RatioShape, windowSeconds: M.bigint() },
-  //   }),
-  // );
   mustMatch(
     offerArgs,
     M.splitRecord(
@@ -78,24 +96,19 @@ export const swapIt = async (
         receiverAddr: M.string(),
         outDenom: M.string(),
         onFailedDelivery: M.string(),
-        slippage: { slippageRatio: RatioShape, windowSeconds: M.bigint() },
+        slippage: { slippagePercentage: M.string(), windowSeconds: M.number() },
       },
-      { nextMemo: M.or(undefined, M.string()) },
+      { nextMemo: M.string() },
     ),
   );
 
-  trace('HELLLOOOOO');
-
-  const { destAddr } = offerArgs;
+  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 ${destAddr}`);
+  void log(`sending {${amt.value}} from osmosis to ${receiverAddr}`);
   const denom = await denomForBrand(orch, amt.brand);
 
-  /** @type {ChainInfo} */
-  const info = await chainHub.getChainInfo('osmosis');
-
   /**
    * @type {any} XXX methods returning vows
    *   https://github.com/Agoric/agoric-sdk/issues/9822
@@ -115,26 +128,29 @@ export const swapIt = async (
     throw makeError(errorMsg);
   };
 
-  const { chainId } = info;
-  assert(typeof chainId === 'string', 'bad chainId');
-
-  const [_a, _o, connection] = await chainHub.getChainsAndConnection(
-    'agoric',
-    'osmosis',
-  );
+  const [_a, osmosisChainInfo, connection] =
+    await chainHub.getChainsAndConnection('agoric', 'osmosis');
 
   connection.counterparty || Fail`No IBC connection to Osmosis`;
 
-  void log(`got info for chain: osmosis ${chainId}`);
+  void log(`got info for chain: osmosis ${osmosisChainInfo}`);
+  trace(osmosisChainInfo);
 
   await localTransfer(seat, sharedLocalAccount, give);
   void log(`completed transfer to localAccount`);
 
   try {
+    const memo = buildXCSMemo(offerArgs);
+    trace(memo);
+
     await sharedLocalAccount.transfer(
-      { value: destAddr, encoding: 'bech32', chainId },
+      {
+        value: destAddr,
+        encoding: 'bech32',
+        chainId: /** @type {CosmosChainInfo} */ (osmosisChainInfo).chainId,
+      },
       { denom, value: amt.value },
-      // memo here
+      { memo },
     );
     void log(`completed transfer to ${destAddr}`);
   } catch (e) {
diff --git a/packages/orchestration/test/examples/swap-anything.test.ts b/packages/orchestration/test/examples/swap-anything.test.ts
@@ -1,25 +1,27 @@
 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 { makeRatio } from '@agoric/ertp/src/ratio.js';
 import * as contractExports from '../../src/examples/swap-anything.contract.js';
 import { commonSetup } from '../supports.js';
 
 const contractName = 'swap-anything';
 type StartFn = typeof contractExports.start;
 
+const config = {
+  xcsInformation: {
+    // A message that we know to be working
+    rawMsgNoNextMemo:
+      '{"wasm":{"contract":"osmo17p9rzwnnfxcjp32un9ug7yhhzgtkhvl9jfksztgw5uh69wac2pgs5yczr8","msg":{"osmosis_swap":{"output_denom":"uosmo","slippage":{"twap":{"window_seconds":10,"slippage_percentage":"20"}},"receiver":"agoric1elueec97as0uwavlxpmj75u5w7yq9dgphq47zx","on_failed_delivery":"do_nothing"}}}}',
+  },
+};
+
 const bootstrapOrchestration = async t => {
   t.log('bootstrap, orchestration core-eval');
   const {
     bootstrap,
     commonPrivateArgs,
     brands: { bld },
-    utils: {
-      inspectLocalBridge,
-      pourPayment,
-      transmitTransferAck,
-      populateChainHub,
-    },
+    utils: { inspectLocalBridge, pourPayment, transmitTransferAck },
   } = await commonSetup(t);
   const vt = bootstrap.vowTools;
 
@@ -34,8 +36,6 @@ const bootstrapOrchestration = async t => {
     contractName,
   );
 
-  populateChainHub();
-
   const swapKit = await E(zoe).startInstance(
     installation,
     { BLD: bld.issuer },
@@ -58,6 +58,38 @@ const bootstrapOrchestration = async t => {
   };
 };
 
+const buildOfferArgs = rawMsg => {
+  const {
+    wasm: {
+      contract,
+      msg: {
+        osmosis_swap: {
+          receiver,
+          output_denom: outDenom,
+          slippage: {
+            twap: {
+              slippage_percentage: slippagePercentage,
+              window_seconds: windowSeconds,
+            },
+          },
+
+          on_failed_delivery: onFailedDelivery,
+          next_memo: nextMemo,
+        },
+      },
+    },
+  } = JSON.parse(rawMsg);
+
+  return {
+    destAddr: contract,
+    receiverAddr: receiver,
+    outDenom,
+    slippage: { slippagePercentage, windowSeconds },
+    onFailedDelivery,
+    nextMemo,
+  };
+};
+
 test('swap BLD for Osmo, receiver on Agoric', async t => {
   const {
     vt,
@@ -76,20 +108,13 @@ test('swap BLD for Osmo, receiver on Agoric', async t => {
 
   const anAmt = bld.units(3.5);
   const Send = await pourPayment(anAmt);
+  const offerArgs = buildOfferArgs(config.xcsInformation.rawMsgNoNextMemo);
+
   const userSeat = await E(zoe).offer(
     inv,
     { give: { Send: anAmt } },
     { Send },
-    {
-      destAddr: 'hot1destAddr',
-      receiverAddr: 'osmosis1xcsaddr',
-      outDenom: 'uosmo',
-      onFailedDelivery: 'doNothing',
-      slippage: {
-        slippageRatio: makeRatio(10n, bld.brand),
-        windowSeconds: 10n,
-      },
-    },
+    offerArgs,
   );
   await transmitTransferAck();
   await vt.when(E(userSeat).getOfferResult());
@@ -105,10 +130,12 @@ test('swap BLD for Osmo, receiver on Agoric', async t => {
     history.find(x => x.type === 'VLOCALCHAIN_EXECUTE_TX')?.messages?.[0],
     {
       '@type': '/ibc.applications.transfer.v1.MsgTransfer',
-      receiver: 'hot1destAddr',
+      receiver: offerArgs.destAddr, // XCS contract has to be the one receiving the IBC message
       sender: 'agoric1fakeLCAAddress',
-      memo: '',
+      memo: config.xcsInformation.rawMsgNoNextMemo,
     },
     'crosschain swap sent',
   );
 });
+
+test.todo('should throw when Osmosis not connected');
