feat: warp send with --chains (#7198)

Author: ltyu

.changeset/curly-garlics-rush.md

@@ -0,0 +1,5 @@
+---
+"@hyperlane-xyz/cli": minor
+---
+
+Update `hyperlane warp send` to include `--chains` parameter to input which chains to send to

typescript/cli/src/commands/warp.ts

@@ -3,14 +3,19 @@ import { stringify as yamlStringify } from 'yaml';
 import { CommandModule } from 'yargs';
 
 import {
-  ChainName,
   RawForkedChainConfigByChain,
   RawForkedChainConfigByChainSchema,
   expandVirtualWarpDeployConfig,
   expandWarpDeployConfig,
   getRouterAddressesFromWarpCoreConfig,
 } from '@hyperlane-xyz/sdk';
-import { ProtocolType, assert, objFilter } from '@hyperlane-xyz/utils';
+import {
+  ProtocolType,
+  assert,
+  difference,
+  intersection,
+  objFilter,
+} from '@hyperlane-xyz/utils';
 
 import { runWarpRouteCheck } from '../check/warp.js';
 import { createWarpRouteDeployConfig } from '../config/warp.js';
@@ -33,7 +38,6 @@ import { getWarpRouteConfigsByCore, runWarpRouteRead } from '../read/warp.js';
 import { RebalancerRunner } from '../rebalancer/runner.js';
 import { sendTestTransfer } from '../send/transfer.js';
 import { ExtendedChainSubmissionStrategySchema } from '../submitters/types.js';
-import { runSingleChainSelectionStep } from '../utils/chains.js';
 import {
   indentYamlOrJson,
   readYamlOrJson,
@@ -258,6 +262,7 @@ const send: CommandModuleWithWriteContext<
       router?: string;
       amount: string;
       recipient?: string;
+      chains?: string;
     }
 > = {
   command: 'send',
@@ -274,6 +279,12 @@ const send: CommandModuleWithWriteContext<
       type: 'string',
       description: 'Token recipient address (defaults to sender)',
     },
+    chains: {
+      type: 'string',
+      description: 'Comma separated list of chains to send messages to',
+      demandOption: false,
+      conflicts: ['origin', 'destination'],
+    },
   },
   handler: async ({
     context,
@@ -287,43 +298,41 @@ const send: CommandModuleWithWriteContext<
     amount,
     recipient,
     roundTrip,
+    chains: chainsAsString,
   }) => {
     const warpCoreConfig = await getWarpCoreConfigOrExit({
       symbol,
       warp,
       context,
     });
+    const chainsToSend = chainsAsString?.split(',').map((_) => _.trim());
+    let chains = chainsToSend || [];
 
-    let chains: ChainName[] = warpCoreConfig.tokens.map((t) => t.chainName);
-    if (roundTrip) {
-      // Appends the reverse of the array, excluding the 1st (e.g. [1,2,3] becomes [1,2,3,2,1])
-      const reversed = [...chains].reverse().slice(1, chains.length + 1); // We make a copy because .reverse() is mutating
-      chains.push(...reversed);
-    } else {
-      // Assume we want to use use `--origin` and `--destination` params, prompt as needed.
-      const chainMetadata = objFilter(
-        context.chainMetadata,
-        (key, _metadata): _metadata is any => chains.includes(key),
-      );
+    if (origin && destination) {
+      chains.push(origin);
+      chains.push(destination);
+    }
 
-      if (!origin)
-        origin = await runSingleChainSelectionStep(
-          chainMetadata,
-          'Select the origin chain:',
-        );
+    const supportedChains = new Set(
+      warpCoreConfig.tokens.map((t) => t.chainName),
+    );
 
-      if (!destination)
-        destination = await runSingleChainSelectionStep(
-          chainMetadata,
-          'Select the destination chain:',
-        );
+    const unsupportedChains = difference(
+      new Set([...(chainsToSend || []), origin, destination].filter(Boolean)),
+      supportedChains,
+    );
+    assert(
+      unsupportedChains.size === 0,
+      `Chain(s) ${[...unsupportedChains].join(', ')} are not part of the warp route.`,
+    );
 
-      chains = [origin, destination].filter((c) => chains.includes(c));
+    chains = [...intersection(new Set(chains), supportedChains)];
+    assert(chains.length > 1, `Not enough chains to send messages.`);
 
-      assert(
-        chains.length === 2,
-        `Origin (${origin}) or destination (${destination}) are not part of the warp route.`,
-      );
+    if (roundTrip) {
+      // Appends the reverse of the array, excluding the 1st (e.g. [1,2,3] becomes [1,2,3,2,1])
+      const reversed = [...chains].reverse().slice(1, chains.length + 1);
+      chains = [...chains, ...reversed];
     }
 
     logBlue(`🚀 Sending a message for chains: ${chains.join(' ➡️ ')}`);

typescript/cli/src/tests/ethereum/commands/warp.ts

@@ -232,23 +232,35 @@ export function hyperlaneWarpCheck(
   });
 }
 
-export function hyperlaneWarpSendRelay(
-  origin: string,
-  destination: string,
-  warpCorePath: string,
+export function hyperlaneWarpSendRelay({
+  origin,
+  destination,
+  warpCorePath,
   relay = true,
-  value: number | string = 1,
-): ProcessPromise {
+  value = 1,
+  chains,
+  roundTrip,
+}: {
+  origin?: string;
+  destination?: string;
+  warpCorePath: string;
+  relay?: boolean;
+  value?: number | string;
+  chains?: string;
+  roundTrip?: boolean;
+}): ProcessPromise {
   return $`${localTestRunCmdPrefix()} hyperlane warp send \
         ${relay ? '--relay' : []} \
         --registry ${REGISTRY_PATH} \
-        --origin ${origin} \
-        --destination ${destination} \
+        ${origin ? ['--origin', origin] : []} \
+        ${destination ? ['--destination', destination] : []} \
         --warp ${warpCorePath} \
         --key ${ANVIL_KEY} \
         --verbosity debug \
         --yes \
-        --amount ${value}`;
+        --amount ${value} \
+        ${chains ? ['--chains', chains] : []} \
+        ${roundTrip ? ['--round-trip'] : []} `;
 }
 
 export function hyperlaneWarpRebalancer(
@@ -640,6 +652,14 @@ export async function sendWarpRouteMessageRoundTrip(
   chain2: string,
   warpCoreConfigPath: string,
 ) {
-  await hyperlaneWarpSendRelay(chain1, chain2, warpCoreConfigPath);
-  return hyperlaneWarpSendRelay(chain2, chain1, warpCoreConfigPath);
+  await hyperlaneWarpSendRelay({
+    origin: chain1,
+    destination: chain2,
+    warpCorePath: warpCoreConfigPath,
+  });
+  return hyperlaneWarpSendRelay({
+    origin: chain2,
+    destination: chain1,
+    warpCorePath: warpCoreConfigPath,
+  });
 }

typescript/cli/src/tests/ethereum/relay.e2e-test.ts

@@ -64,18 +64,18 @@ describe('hyperlane relayer e2e tests', async function () {
         WARP_DEPLOY_OUTPUT,
       );
 
-      await hyperlaneWarpSendRelay(
-        CHAIN_NAME_2,
-        CHAIN_NAME_3,
-        WARP_DEPLOY_OUTPUT,
-        false,
-      );
-      await hyperlaneWarpSendRelay(
-        CHAIN_NAME_3,
-        CHAIN_NAME_2,
-        WARP_DEPLOY_OUTPUT,
-        false,
-      );
+      await hyperlaneWarpSendRelay({
+        origin: CHAIN_NAME_2,
+        destination: CHAIN_NAME_3,
+        warpCorePath: WARP_DEPLOY_OUTPUT,
+        relay: false,
+      });
+      await hyperlaneWarpSendRelay({
+        origin: CHAIN_NAME_3,
+        destination: CHAIN_NAME_2,
+        warpCorePath: WARP_DEPLOY_OUTPUT,
+        relay: false,
+      });
 
       await process.kill('SIGINT');
     });

typescript/cli/src/tests/ethereum/warp/warp-deploy.e2e-test.ts

@@ -708,28 +708,28 @@ describe('hyperlane warp deploy e2e tests', async function () {
       await hyperlaneWarpDeploy(WARP_DEPLOY_OUTPUT_PATH);
 
       // Try to send a transaction with the origin destination
-      const { stdout: chain2Tochain3Stdout } = await hyperlaneWarpSendRelay(
-        CHAIN_NAME_2,
-        CHAIN_NAME_3,
-        WARP_CORE_CONFIG_PATH_2_3,
-      );
+      const { stdout: chain2Tochain3Stdout } = await hyperlaneWarpSendRelay({
+        origin: CHAIN_NAME_2,
+        destination: CHAIN_NAME_3,
+        warpCorePath: WARP_CORE_CONFIG_PATH_2_3,
+      });
       expect(chain2Tochain3Stdout).to.include('anvil2 ➡️ anvil3');
 
       // Send another message with swapped origin destination
-      const { stdout: chain3Tochain2Stdout } = await hyperlaneWarpSendRelay(
-        CHAIN_NAME_3,
-        CHAIN_NAME_2,
-        WARP_CORE_CONFIG_PATH_2_3,
-      );
+      const { stdout: chain3Tochain2Stdout } = await hyperlaneWarpSendRelay({
+        origin: CHAIN_NAME_3,
+        destination: CHAIN_NAME_2,
+        warpCorePath: WARP_CORE_CONFIG_PATH_2_3,
+      });
       expect(chain3Tochain2Stdout).to.include('anvil3 ➡️ anvil2');
 
       // Should throw if invalid origin or destination
-      await hyperlaneWarpSendRelay(
-        'anvil1',
-        CHAIN_NAME_3,
-        WARP_CORE_CONFIG_PATH_2_3,
-      ).should.be.rejectedWith(
-        'Error: Origin (anvil1) or destination (anvil3) are not part of the warp route.',
+      await hyperlaneWarpSendRelay({
+        origin: 'anvil1',
+        destination: CHAIN_NAME_3,
+        warpCorePath: WARP_CORE_CONFIG_PATH_2_3,
+      }).should.be.rejectedWith(
+        'Error: Chain(s) anvil1 are not part of the warp route.',
       );
     });
 

typescript/cli/src/tests/ethereum/warp/warp-rebalancer.e2e-test.ts

@@ -160,21 +160,21 @@ describe('hyperlane warp rebalancer e2e tests', async function () {
     console.log('Bridging tokens...');
 
     await Promise.all([
-      hyperlaneWarpSendRelay(
-        CHAIN_NAME_2,
-        CHAIN_NAME_4,
-        warpCoreConfigPath,
-        true,
-        toWei(10),
-      ),
+      hyperlaneWarpSendRelay({
+        origin: CHAIN_NAME_2,
+        destination: CHAIN_NAME_4,
+        warpCorePath: warpCoreConfigPath,
+        relay: true,
+        value: toWei(10),
+      }),
       sleep(2000).then(() =>
-        hyperlaneWarpSendRelay(
-          CHAIN_NAME_3,
-          CHAIN_NAME_4,
-          warpCoreConfigPath,
-          true,
-          toWei(10),
-        ),
+        hyperlaneWarpSendRelay({
+          origin: CHAIN_NAME_3,
+          destination: CHAIN_NAME_4,
+          warpCorePath: warpCoreConfigPath,
+          relay: true,
+          value: toWei(10),
+        }),
       ),
     ]);
   });
@@ -1235,13 +1235,13 @@ describe('hyperlane warp rebalancer e2e tests', async function () {
     // This process locks tokens on the destination chain and unlocks them on the origin,
     // effectively increasing collateral on the destination while decreasing it on the origin,
     // which achieves the desired rebalancing effect.
-    await hyperlaneWarpSendRelay(
-      destName,
-      originName,
-      warpCoreConfigPath,
-      true,
-      sentTransferRemote.amount.toString(),
-    );
+    await hyperlaneWarpSendRelay({
+      origin: destName,
+      destination: originName,
+      warpCorePath: warpCoreConfigPath,
+      relay: true,
+      value: sentTransferRemote.amount.toString(),
+    });
 
     originBalance = await originTkn.balanceOf(originContractAddress);
     destBalance = await destTkn.balanceOf(destContractAddress);
@@ -1701,13 +1701,13 @@ describe('hyperlane warp rebalancer e2e tests', async function () {
       // This process locks tokens on the destination chain and unlocks them on the origin,
       // effectively increasing collateral on the destination while decreasing it on the origin,
       // which achieves the desired rebalancing effect.
-      await hyperlaneWarpSendRelay(
-        destName,
-        originName,
-        warpCoreConfigPath,
-        true,
-        sentTransferRemote.amount.toString(),
-      );
+      await hyperlaneWarpSendRelay({
+        origin: destName,
+        destination: originName,
+        warpCorePath: warpCoreConfigPath,
+        relay: true,
+        value: sentTransferRemote.amount.toString(),
+      });
 
       originBalance = await originTkn.balanceOf(originContractAddress);
       destBalance = await destTkn.balanceOf(destContractAddress);