feat: evm multi chain signer

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Launch Program",
+      "skipFiles": ["<node_internals>/**"],
+      "program": "$${workspaceFolder}/**/*.ts",
+      "outFiles": ["${workspaceFolder}/**/*.js"]
+    }
+  ]
+}

typescript/cli/cli.ts

@@ -24,10 +24,11 @@ import { registryCommand } from './src/commands/registry.js';
 import { relayerCommand } from './src/commands/relayer.js';
 import { sendCommand } from './src/commands/send.js';
 import { statusCommand } from './src/commands/status.js';
+import { strategyCommand } from './src/commands/strategy.js';
 import { submitCommand } from './src/commands/submit.js';
 import { validatorCommand } from './src/commands/validator.js';
 import { warpCommand } from './src/commands/warp.js';
-import { contextMiddleware } from './src/context/context.js';
+import { contextMiddleware, signerMiddleware } from './src/context/context.js';
 import { configureLogger, errorRed } from './src/logger.js';
 import { checkVersion } from './src/utils/version-check.js';
 import { VERSION } from './src/version.js';
@@ -55,6 +56,7 @@ try {
         configureLogger(argv.log as LogFormat, argv.verbosity as LogLevel);
       },
       contextMiddleware,
+      signerMiddleware,
     ])
     .command(avsCommand)
     .command(configCommand)
@@ -69,6 +71,7 @@ try {
     .command(submitCommand)
     .command(validatorCommand)
     .command(warpCommand)
+    .command(strategyCommand)
     .version(VERSION)
     .demandCommand()
     .strict()

typescript/cli/src/commands/options.ts

@@ -95,6 +95,7 @@ export const DEFAULT_WARP_ROUTE_DEPLOYMENT_CONFIG_PATH =
   './configs/warp-route-deployment.yaml';
 
 export const DEFAULT_CORE_DEPLOYMENT_CONFIG_PATH = './configs/core-config.yaml';
+export const DEFAULT_STRATEGY_CONFIG_PATH = `${os.homedir()}/.hyperlane/strategies/default-strategy.yaml`;
 
 export const warpDeploymentConfigCommandOption: Options = {
   type: 'string',
@@ -127,6 +128,13 @@ export const chainTargetsCommandOption: Options = {
   alias: 'c',
 };
 
+export const strategyConfigUrlCommandOption: Options = {
+  type: 'string',
+  description: 'A path to a JSON or YAML file with a strategy config.',
+  default: DEFAULT_STRATEGY_CONFIG_PATH,
+  alias: 's',
+};
+
 export const outputFileCommandOption = (
   defaultPath?: string,
   demandOption = false,

typescript/cli/src/commands/send.ts

@@ -46,8 +46,8 @@ export const messageOptions: { [k: string]: Options } = {
 };
 
 export interface MessageOptionsArgTypes {
-  origin?: string;
-  destination?: string;
+  origin: string;
+  destination: string;
   timeout: number;
   quick: boolean;
   relay: boolean;

typescript/cli/src/commands/signCommands.ts

@@ -1,7 +1,7 @@
 // Commands that send tx and require a key to sign.
 // It's useful to have this listed here so the context
 // middleware can request keys up front when required.
-export const SIGN_COMMANDS = ['deploy', 'send', 'status', 'submit'];
+export const SIGN_COMMANDS = ['deploy', 'send', 'status', 'apply'];
 
 export function isSignCommand(argv: any): boolean {
   return (

typescript/cli/src/commands/strategy.ts

@@ -0,0 +1,207 @@
+// import { input, select } from '@inquirer/prompts';
+import { input, select } from '@inquirer/prompts';
+import { ethers } from 'ethers';
+import { stringify as yamlStringify } from 'yaml';
+import { CommandModule } from 'yargs';
+
+import {
+  ChainSubmissionStrategy,
+  ChainSubmissionStrategySchema,
+  TxSubmitterType,
+} from '@hyperlane-xyz/sdk';
+import { ProtocolType, assert } from '@hyperlane-xyz/utils';
+
+import { CommandModuleWithWriteContext } from '../context/types.js';
+import {
+  errorRed,
+  log,
+  logBlue,
+  logCommandHeader,
+  logGreen,
+} from '../logger.js';
+import { runSingleChainSelectionStep } from '../utils/chains.js';
+import {
+  indentYamlOrJson,
+  readYamlOrJson,
+  writeYamlOrJson,
+} from '../utils/files.js';
+
+import {
+  DEFAULT_STRATEGY_CONFIG_PATH,
+  outputFileCommandOption,
+} from './options.js';
+
+/**
+ * Parent command
+ */
+export const strategyCommand: CommandModule = {
+  command: 'strategy',
+  describe: 'Manage Hyperlane deployment strategies',
+  builder: (yargs) => yargs.command(init).version(false).demandCommand(),
+  handler: () => log('Command required'),
+};
+
+export const init: CommandModuleWithWriteContext<{
+  chain: string;
+  config: string;
+}> = {
+  command: 'init',
+  describe: 'Initiates strategy',
+  builder: {
+    config: outputFileCommandOption(
+      DEFAULT_STRATEGY_CONFIG_PATH,
+      false,
+      'The path to output a Strategy Config JSON or YAML file.',
+    ),
+    type: {
+      type: 'string',
+      description:
+        'Type of submitter (jsonRpc, impersonatedAccount, gnosisSafe, gnosisSafeTxBuilder)',
+    },
+    safeAddress: {
+      type: 'string',
+      description:
+        'Safe address (required for gnosisSafe and gnosisSafeTxBuilder types)',
+    },
+    userAddress: {
+      type: 'string',
+      description: 'User address (required for impersonatedAccount type)',
+    },
+  },
+  handler: async ({
+    context,
+    type: inputType,
+    safeAddress: inputSafeAddress,
+    userAddress: inputUserAddress,
+  }) => {
+    logCommandHeader(`Hyperlane Key Init`);
+    let defaultStrategy;
+    try {
+      defaultStrategy = await readYamlOrJson(DEFAULT_STRATEGY_CONFIG_PATH);
+    } catch (e) {
+      defaultStrategy = writeYamlOrJson(
+        DEFAULT_STRATEGY_CONFIG_PATH,
+        {},
+        'yaml',
+      );
+    }
+
+    const chain = await runSingleChainSelectionStep(context.chainMetadata);
+    const chainProtocol = context.chainMetadata[chain].protocol;
+    assert(chainProtocol === ProtocolType.Ethereum, 'Incompatible protocol');
+
+    // If type wasn't provided via command line, prompt for it
+    const type =
+      inputType ||
+      (await select({
+        message: 'Enter the type of submitter',
+        choices: Object.values(TxSubmitterType).map((value) => ({
+          name: value,
+          value: value,
+        })),
+      }));
+
+    const submitter: any = {
+      type: type,
+    };
+
+    // Configure submitter based on type
+    switch (type) {
+      case TxSubmitterType.JSON_RPC:
+        submitter.privateKey = await input({
+          message: 'Enter your private key',
+          validate: (pk) => isValidPrivateKey(pk),
+        });
+        submitter.chain = chain;
+        break;
+
+      case TxSubmitterType.IMPERSONATED_ACCOUNT:
+        submitter.userAddress =
+          inputUserAddress ||
+          (await input({
+            message: 'Enter the user address to impersonate',
+            validate: (address) => {
+              try {
+                return ethers.utils.isAddress(address)
+                  ? true
+                  : 'Invalid Ethereum address';
+              } catch {
+                return 'Invalid Ethereum address';
+              }
+            },
+          }));
+        assert(
+          submitter.userAddress,
+          'User address is required for impersonated account',
+        );
+        break;
+
+      case TxSubmitterType.GNOSIS_SAFE:
+      case TxSubmitterType.GNOSIS_TX_BUILDER:
+        submitter.safeAddress =
+          inputSafeAddress ||
+          (await input({
+            message: 'Enter the Safe address',
+            validate: (address) => {
+              try {
+                return ethers.utils.isAddress(address)
+                  ? true
+                  : 'Invalid Safe address';
+              } catch {
+                return 'Invalid Safe address';
+              }
+            },
+          }));
+        assert(
+          submitter.safeAddress,
+          'Safe address is required for Gnosis Safe',
+        );
+        submitter.chain = chain;
+
+        if (type === TxSubmitterType.GNOSIS_TX_BUILDER) {
+          submitter.version = await input({
+            message: 'Enter the Safe version (default: 1.0)',
+            default: '1.0',
+          });
+        }
+        break;
+
+      default:
+        throw new Error(`Unsupported submitter type: ${type}`);
+    }
+
+    const result: ChainSubmissionStrategy = {
+      ...defaultStrategy, // if there are changes in ChainSubmissionStrategy, the defaultStrategy may no longer be compatible
+      [chain]: {
+        submitter: submitter,
+      },
+    };
+
+    try {
+      const strategyConfig = ChainSubmissionStrategySchema.parse(result);
+      logBlue(
+        `Strategy config is valid, writing to file ${DEFAULT_STRATEGY_CONFIG_PATH}:\n`,
+      );
+      log(indentYamlOrJson(yamlStringify(strategyConfig, null, 2), 4));
+
+      writeYamlOrJson(DEFAULT_STRATEGY_CONFIG_PATH, strategyConfig);
+      logGreen('✅ Successfully created new key config.');
+    } catch (e) {
+      errorRed(
+        `Key config is invalid, please check the submitter configuration.`,
+      );
+      throw e;
+    }
+    process.exit(0);
+  },
+};
+
+function isValidPrivateKey(privateKey: string): boolean {
+  try {
+    // Attempt to create a Wallet instance with the private key
+    const wallet = new ethers.Wallet(privateKey);
+    return wallet.privateKey === privateKey;
+  } catch (error) {
+    return false;
+  }
+}

typescript/cli/src/config/strategy.ts

@@ -0,0 +1,16 @@
+import {
+  ChainSubmissionStrategy,
+  ChainSubmissionStrategySchema,
+} from '@hyperlane-xyz/sdk';
+import { assert } from '@hyperlane-xyz/utils';
+
+import { readYamlOrJson } from '../utils/files.js';
+
+export async function readDefaultStrategyConfig(
+  filePath: string,
+): Promise<ChainSubmissionStrategy> {
+  const config = readYamlOrJson(filePath);
+  assert(config, `No default strategy config found at ${filePath}`);
+
+  return ChainSubmissionStrategySchema.parse(config);
+}