feat: add pending transactions to strategy

.changeset/polite-bulldogs-sit.md

@@ -1,5 +1,5 @@
 ---
-"@hyperlane-xyz/cli": patch
+'@hyperlane-xyz/cli': patch
 ---
 
 Fix strategy flag propagation

.changeset/popular-glasses-admire.md

@@ -0,0 +1,6 @@
+---
+'@hyperlane-xyz/cli': minor
+'@hyperlane-xyz/sdk': minor
+---
+
+Implement pending state on tx submitters

tsconfig.json

@@ -15,7 +15,7 @@
     "noFallthroughCasesInSwitch": true,
     "noImplicitAny": true,
     "noImplicitReturns": true,
-    "noUnusedLocals": true,
+    "noUnusedLocals": false,
     "preserveSymlinks": true,
     "preserveWatchOutput": true,
     "pretty": false,

typescript/cli/cli.ts

@@ -26,7 +26,6 @@ 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, signerMiddleware } from './src/context/context.js';
@@ -68,7 +67,6 @@ try {
     .command(sendCommand)
     .command(statusCommand)
     .command(strategyCommand)
-    .command(submitCommand)
     .command(validatorCommand)
     .command(warpCommand)
     .version(VERSION)

typescript/cli/src/commands/signCommands.ts

@@ -8,6 +8,7 @@ export const SIGN_COMMANDS = [
   'status',
   'submit',
   'relayer',
+  'pending', // gnosis safe service auth
 ];
 
 export function isSignCommand(argv: any): boolean {

typescript/cli/src/commands/strategy.ts

@@ -1,19 +1,30 @@
 import { stringify as yamlStringify } from 'yaml';
 import { CommandModule } from 'yargs';
 
+import { objMap, promiseObjAll } from '@hyperlane-xyz/utils';
+
 import {
   createStrategyConfig,
   readChainSubmissionStrategyConfig,
+  readSubmissionStrategyConfig,
 } from '../config/strategy.js';
+import { runSubmit } from '../config/submit.js';
 import { CommandModuleWithWriteContext } from '../context/types.js';
-import { log, logCommandHeader } from '../logger.js';
-import { indentYamlOrJson } from '../utils/files.js';
+import { readChainSubmissionStrategy } from '../deploy/warp.js';
+import { log, logCommandHeader, logGray } from '../logger.js';
+import { getSubmitterBuilder } from '../submit/submit.js';
+import {
+  indentYamlOrJson,
+  logYamlIfUnderMaxLines,
+  writeYamlOrJson,
+} from '../utils/files.js';
 import { maskSensitiveData } from '../utils/output.js';
 
 import {
   DEFAULT_STRATEGY_CONFIG_PATH,
   outputFileCommandOption,
   strategyCommandOption,
+  transactionsCommandOption,
 } from './options.js';
 
 /**
@@ -23,7 +34,13 @@ export const strategyCommand: CommandModule = {
   command: 'strategy',
   describe: 'Manage Hyperlane deployment strategies',
   builder: (yargs) =>
-    yargs.command(init).command(read).version(false).demandCommand(),
+    yargs
+      .command(init)
+      .command(read)
+      .command(pending)
+      .command(submit)
+      .version(false)
+      .demandCommand(),
   handler: () => log('Command required'),
 };
 
@@ -68,3 +85,70 @@ export const read: CommandModuleWithWriteContext<{
     process.exit(0);
   },
 };
+
+export const pending: CommandModuleWithWriteContext<{
+  strategy: string;
+  transactions: string;
+}> = {
+  command: 'pending',
+  describe: 'Fetches strategy pending transactions',
+  builder: {
+    transactions: {
+      ...transactionsCommandOption,
+      demandOption: false,
+      default: './generated/transactions.yaml',
+    },
+    strategy: {
+      ...strategyCommandOption,
+      demandOption: true,
+    },
+  },
+  handler: async ({ context, transactions }) => {
+    logCommandHeader(`Hyperlane Strategy Pending`);
+
+    const chainStrategy = readChainSubmissionStrategy(context.strategyPath!);
+
+    const pending = await promiseObjAll(
+      objMap(chainStrategy, async (_, submissionStrategy) => {
+        const submitter = await getSubmitterBuilder({
+          submissionStrategy,
+          multiProvider: context.multiProvider,
+        });
+        return submitter.pending();
+      }),
+    );
+
+    logYamlIfUnderMaxLines(pending);
+
+    logGray(`Writing pending transactions to ${transactions}`);
+    writeYamlOrJson(transactions, pending);
+  },
+};
+
+export const submit: CommandModuleWithWriteContext<{
+  strategy: string;
+  transactions: string;
+  receipts: string;
+}> = {
+  command: 'submit',
+  describe: 'Submit transactions',
+  builder: {
+    transactions: transactionsCommandOption,
+    strategy: strategyCommandOption,
+    receipts: outputFileCommandOption('./generated/transactions/receipts.yaml'),
+  },
+  handler: async ({
+    context,
+    transactions,
+    strategy: strategyUrl,
+    receipts,
+  }) => {
+    const submissionStrategy = readSubmissionStrategyConfig(strategyUrl);
+    await runSubmit({
+      context,
+      transactionsFilepath: transactions,
+      receiptsFilepath: receipts,
+      submissionStrategy,
+    });
+  },
+};

typescript/cli/src/config/strategy.ts

@@ -5,6 +5,8 @@ import { stringify as yamlStringify } from 'yaml';
 import {
   ChainSubmissionStrategy,
   ChainSubmissionStrategySchema,
+  SubmissionStrategy,
+  SubmissionStrategySchema,
   TxSubmitterType,
 } from '@hyperlane-xyz/sdk';
 import {
@@ -24,6 +26,14 @@ import {
 } from '../utils/files.js';
 import { maskSensitiveData } from '../utils/output.js';
 
+export function readSubmissionStrategyConfig(
+  filePath: string,
+): SubmissionStrategy {
+  log(`Reading submission strategy in ${filePath}`);
+  const strategyConfig = readYamlOrJson<SubmissionStrategy>(filePath);
+  return SubmissionStrategySchema.parse(strategyConfig);
+}
+
 /**
  * Reads and validates a chain submission strategy configuration from a file
  */

typescript/sdk/src/providers/transactions/submitter/TxSubmitterInterface.ts

@@ -28,4 +28,8 @@ export interface TxSubmitterInterface<TProtocol extends ProtocolType> {
     | ProtocolTypedReceipt<TProtocol>['receipt'][]
     | void
   >;
+
+  pending(): Promise<
+    Annotated<ProtocolTypedTransaction<TProtocol>['transaction']>[]
+  >;
 }

typescript/sdk/src/providers/transactions/submitter/builder/TxSubmitterBuilder.ts

@@ -97,4 +97,10 @@ export class TxSubmitterBuilder<TProtocol extends ProtocolType>
 
     return txReceipts;
   }
+
+  public async pending(): Promise<
+    Annotated<ProtocolTypedTransaction<TProtocol>['transaction']>[]
+  > {
+    return this.currentSubmitter.pending();
+  }
 }

typescript/sdk/src/providers/transactions/submitter/ethersV5/EV5GnosisSafeTxSubmitter.ts

@@ -1,4 +1,7 @@
+import SafeApiKit from '@safe-global/api-kit';
+import Safe from '@safe-global/protocol-kit';
 import { SafeTransaction } from '@safe-global/safe-core-sdk-types';
+import { BigNumber } from 'ethers';
 import { Logger } from 'pino';
 
 import { Address, assert, rootLogger } from '@hyperlane-xyz/utils';
@@ -24,8 +27,8 @@ export class EV5GnosisSafeTxSubmitter implements EV5TxSubmitterInterface {
   constructor(
     public readonly multiProvider: MultiProvider,
     public readonly props: EV5GnosisSafeTxSubmitterProps,
-    private safe: any,
-    private safeService: any,
+    private safe: Safe.default,
+    private safeService: SafeApiKit.default,
   ) {}
 
   static async create(
@@ -74,6 +77,10 @@ export class EV5GnosisSafeTxSubmitter implements EV5TxSubmitterInterface {
     );
     const submitterChainId = this.multiProvider.getChainId(this.props.chain);
     assert(chainId, 'Invalid AnnotatedEV5Transaction: chainId is required');
+    // TODO: fix types
+    assert(to, 'Invalid AnnotatedEV5Transaction: to is required');
+    assert(data, 'Invalid AnnotatedEV5Transaction: data is required');
+
     assert(
       chainId === submitterChainId,
       `Invalid AnnotatedEV5Transaction: Cannot submit tx for chain ID ${chainId} to submitter for chain ID ${submitterChainId}.`,
@@ -84,6 +91,24 @@ export class EV5GnosisSafeTxSubmitter implements EV5TxSubmitterInterface {
     });
   }
 
+  public async pending(nonce?: number): Promise<AnnotatedEV5Transaction[]> {
+    const safeTransactions = await this.safeService.getPendingTransactions(
+      this.props.safeAddress,
+      nonce,
+    );
+    const chainId = this.multiProvider.getEvmChainId(this.props.chain);
+    const from = this.props.safeAddress;
+    return safeTransactions.results.map(
+      (tx): AnnotatedEV5Transaction => ({
+        chainId,
+        from,
+        to: tx.to,
+        data: tx.data,
+        value: BigNumber.from(tx.value),
+      }),
+    );
+  }
+
   public async submit(...txs: AnnotatedEV5Transaction[]): Promise<any> {
     return this.proposeIndividualTransactions(txs);
   }

typescript/sdk/src/providers/transactions/submitter/ethersV5/EV5JsonRpcTxSubmitter.ts

@@ -45,4 +45,9 @@ export class EV5JsonRpcTxSubmitter implements EV5TxSubmitterInterface {
     }
     return receipts;
   }
+
+  public async pending(): Promise<AnnotatedEV5Transaction[]> {
+    // TODO: mempool?
+    return [];
+  }
 }