Merge branch 'main' into storage-snapshots

.changeset/little-beans-attack.md

@@ -0,0 +1,5 @@
+---
+'@hyperlane-xyz/cli': patch
+---
+
+Improve warp and kurtosis deploy command UX

rust/Cargo.toml

@@ -183,27 +183,27 @@ cosmwasm-schema = "1.2.7"
 [workspace.dependencies.ethers]
 features = []
 git = "https://github.com/hyperlane-xyz/ethers-rs"
-tag = "2023-11-29-01"
+tag = "2023-11-29-02"
 
 [workspace.dependencies.ethers-contract]
 features = ["legacy"]
 git = "https://github.com/hyperlane-xyz/ethers-rs"
-tag = "2023-11-29-01"
+tag = "2023-11-29-02"
 
 [workspace.dependencies.ethers-core]
 features = []
 git = "https://github.com/hyperlane-xyz/ethers-rs"
-tag = "2023-11-29-01"
+tag = "2023-11-29-02"
 
 [workspace.dependencies.ethers-providers]
 features = []
 git = "https://github.com/hyperlane-xyz/ethers-rs"
-tag = "2023-11-29-01"
+tag = "2023-11-29-02"
 
 [workspace.dependencies.ethers-signers]
 features = ["aws"]
 git = "https://github.com/hyperlane-xyz/ethers-rs"
-tag = "2023-11-29-01"
+tag = "2023-11-29-02"
 
 [patch.crates-io.curve25519-dalek]
 branch = "v3.2.2-relax-zeroize"

typescript/cli/src/commands/deploy.ts

@@ -38,26 +38,29 @@ const agentCommand: CommandModule = {
   describe: 'Deploy Hyperlane agents with Kurtosis',
   builder: (yargs) =>
     yargs.options({
-      originChain: {
+      origin: {
         type: 'string',
         description: 'The name of the origin chain to deploy to',
       },
-      agentConfiguration: agentConfigurationOption,
-      relayChains: {
+      targets: {
         type: 'string',
         description: 'Comma separated list of chains to relay between',
       },
+      chains: chainsCommandOption,
+      config: agentConfigurationOption,
     }),
   handler: async (argv: any) => {
     logGray('Hyperlane Agent Deployment with Kurtosis');
     logGray('----------------------------------------');
-    const originChain: string = argv.originChain;
-    const agentConfigurationPath: string = argv.agentConfiguration;
-    const relayChains: string = argv.relayChains;
+    const chainConfigPath: string = argv.chains;
+    const originChain: string = argv.origin;
+    const agentConfigurationPath: string = argv.config;
+    const relayChains: string = argv.targets;
     await runKurtosisAgentDeploy({
       originChain,
-      agentConfigurationPath,
       relayChains,
+      chainConfigPath,
+      agentConfigurationPath,
     });
     process.exit(0);
   },

typescript/cli/src/commands/options.ts

@@ -25,13 +25,12 @@ export const outDirCommandOption: Options = {
 export const coreArtifactsOption: Options = {
   type: 'string',
   description: 'File path to core deployment output artifacts',
-  alias: 'ca',
+  alias: 'a',
 };
 
 export const agentConfigurationOption: Options = {
   type: 'string',
   description: 'File path to agent configuration artifacts',
-  alias: 'ac',
 };
 
 export const fileFormatOption: Options = {

typescript/cli/src/config/artifacts.ts

@@ -1,9 +1,10 @@
+import { confirm } from '@inquirer/prompts';
 import { ZodTypeAny, z } from 'zod';
 
-import { HyperlaneContractsMap } from '@hyperlane-xyz/sdk';
+import { ChainName, HyperlaneContractsMap } from '@hyperlane-xyz/sdk';
 
-import { logBlue } from '../../logger.js';
-import { readYamlOrJson } from '../utils/files.js';
+import { log, logBlue, logRed } from '../../logger.js';
+import { readYamlOrJson, runFileSelectionStep } from '../utils/files.js';
 
 const RecursiveObjectSchema: ZodTypeAny = z.lazy(() =>
   z.object({}).catchall(z.union([z.string(), RecursiveObjectSchema])),
@@ -31,3 +32,36 @@ export function readDeploymentArtifacts(filePath: string) {
   }
   return artifacts;
 }
+
+export async function runDeploymentArtifactStep(
+  artifactsPath?: string,
+  message?: string,
+  selectedChains?: ChainName[],
+) {
+  if (!artifactsPath) {
+    const useArtifacts = await confirm({
+      message: message || 'Do you want use some existing contract addresses?',
+    });
+    if (!useArtifacts) return undefined;
+
+    artifactsPath = await runFileSelectionStep(
+      './artifacts',
+      'contract artifacts',
+      'core-deployment',
+    );
+  }
+  const artifacts = readDeploymentArtifacts(artifactsPath);
+
+  if (selectedChains) {
+    const artifactChains = Object.keys(artifacts).filter((c) =>
+      selectedChains.includes(c),
+    );
+    if (artifactChains.length === 0) {
+      logRed('No artifacts found for selected chains');
+    } else {
+      log(`Found existing artifacts for chains: ${artifactChains.join(', ')}`);
+    }
+  }
+
+  return artifacts;
+}

typescript/cli/src/context.ts

@@ -3,26 +3,42 @@ import { ethers } from 'ethers';
 import {
   ChainMap,
   ChainMetadata,
+  ChainName,
   HyperlaneContractsMap,
   MultiProvider,
   chainMetadata,
   hyperlaneEnvironments,
 } from '@hyperlane-xyz/sdk';
-import { objMerge } from '@hyperlane-xyz/utils';
+import { objFilter, objMap, objMerge } from '@hyperlane-xyz/utils';
 
 import { readChainConfigsIfExists } from './config/chain.js';
 import { keyToSigner } from './utils/keys.js';
 
-export const sdkContractAddressesMap = {
+export const sdkContractAddressesMap: HyperlaneContractsMap<any> = {
   ...hyperlaneEnvironments.testnet,
   ...hyperlaneEnvironments.mainnet,
 };
 
 export function getMergedContractAddresses(
   artifacts?: HyperlaneContractsMap<any>,
+  chains?: ChainName[],
 ) {
+  // if chains include non sdkContractAddressesMap chains, don't recover interchainGasPaymaster
+  let sdkContractsAddressesToRecover = sdkContractAddressesMap;
+  if (
+    chains?.some(
+      (chain) => !Object.keys(sdkContractAddressesMap).includes(chain),
+    )
+  ) {
+    sdkContractsAddressesToRecover = objMap(sdkContractAddressesMap, (_, v) =>
+      objFilter(
+        v as ChainMap<any>,
+        (key, v): v is any => key !== 'interchainGasPaymaster',
+      ),
+    );
+  }
   return objMerge(
-    sdkContractAddressesMap,
+    sdkContractsAddressesToRecover,
     artifacts || {},
   ) as HyperlaneContractsMap<any>;
 }

typescript/cli/src/deploy/agent.ts

@@ -1,26 +1,40 @@
-import { input } from '@inquirer/prompts';
 import terminalLink from 'terminal-link';
 
-import { logBlue, logGreen, logRed } from '../../logger.js';
+import { toBase64 } from '@hyperlane-xyz/utils';
+
+import { logBlue, logGreen } from '../../logger.js';
+import { getContext } from '../context.js';
+import {
+  runMultiChainSelectionStep,
+  runSingleChainSelectionStep,
+} from '../utils/chains.js';
 import { readJson, runFileSelectionStep } from '../utils/files.js';
 
 export async function runKurtosisAgentDeploy({
   originChain,
-  agentConfigurationPath,
   relayChains,
+  chainConfigPath,
+  agentConfigurationPath,
 }: {
   originChain: string;
-  agentConfigurationPath: string;
   relayChains: string;
+  chainConfigPath: string;
+  agentConfigurationPath: string;
 }) {
+  const { customChains } = getContext(chainConfigPath);
+
   if (!originChain) {
-    originChain = await input({ message: 'Enter the origin chain' });
+    originChain = await runSingleChainSelectionStep(
+      customChains,
+      'Select the origin chain',
+    );
   }
   if (!relayChains) {
-    relayChains = await input({
-      message: 'Enter a comma separated list of chains to relay between',
-    });
-    relayChains = trimSpaces(relayChains);
+    const selectedRelayChains = await runMultiChainSelectionStep(
+      customChains,
+      'Select chains to relay between',
+    );
+    relayChains = selectedRelayChains.join(',');
   }
 
   if (!agentConfigurationPath) {
@@ -48,7 +62,7 @@ export async function runKurtosisAgentDeploy({
     args: hyperlanePackageArgs,
   };
 
-  const base64EncodedPackageConfig = jsonToBase64(kurtosisPackageConfig);
+  const base64EncodedPackageConfig = toBase64(kurtosisPackageConfig) || '';
   const kurtosisCloudUrl = getKurtosisCloudUrl(base64EncodedPackageConfig);
 
   const kurtosisCloudLink = terminalLink(
@@ -67,18 +81,3 @@ export async function runKurtosisAgentDeploy({
 
 const getKurtosisCloudUrl = (base64Params: string) =>
   `https://cloud.kurtosis.com/enclave-manager?package-id=github.com%2Fkurtosis-tech%2Fhyperlane-package&package-args=${base64Params}`;
-
-const trimSpaces = (a: string) =>
-  a
-    .split('')
-    .filter((char) => char !== ' ')
-    .join('');
-
-function jsonToBase64(jsonData: any): string {
-  try {
-    return btoa(JSON.stringify(jsonData));
-  } catch (error) {
-    logRed('Error occurred creating kurtosis cloud url.');
-    return '';
-  }
-}