feat(infra): squads tx parsing (#7263)

Author: paulbalaji

typescript/infra/scripts/sealevel-helpers/print-multisig-ism-config.ts

@@ -1,31 +1,15 @@
-import path from 'path';
-
-import { ChainName, IsmType } from '@hyperlane-xyz/sdk';
+import { IsmType } from '@hyperlane-xyz/sdk';
 
 import { Contexts } from '../../config/contexts.js';
 import { multisigIsms } from '../../config/multisigIsm.js';
 import { getChains } from '../../config/registry.js';
-import { DeployEnvironment } from '../../src/config/environment.js';
-import {
-  assertContext,
-  getMonorepoRoot,
-  writeAndFormatJsonAtPath,
-} from '../../src/utils/utils.js';
+import { multisigIsmConfigPath } from '../../src/utils/sealevel.js';
+import { writeAndFormatJsonAtPath } from '../../src/utils/utils.js';
 import { getArgs, withWrite } from '../agent-utils.js';
 
 // This script exists to print the default multisig ISM validator sets for a given environment
 // so they can easily be copied into the Sealevel tooling. :'(
 
-const multisigIsmConfigPath = (
-  environment: DeployEnvironment,
-  context: Contexts,
-  local: ChainName,
-) =>
-  path.resolve(
-    getMonorepoRoot(),
-    `rust/sealevel/environments/${environment}/multisig-ism-message-id/${local}/${context}/multisig-config.json`,
-  );
-
 async function main() {
   const {
     environment,

typescript/infra/scripts/squads/get-pending-txs.ts

@@ -9,8 +9,10 @@ import {
 } from '@hyperlane-xyz/utils';
 
 import { squadsConfigs } from '../../src/config/squads.js';
-import { logTable } from '../../src/utils/log.js';
-import { getPendingProposalsForChains } from '../../src/utils/squads.js';
+import {
+  getPendingProposalsForChains,
+  logProposals,
+} from '../../src/utils/squads.js';
 import { withChains } from '../agent-utils.js';
 import { getEnvironmentConfig } from '../core-utils.js';
 
@@ -52,16 +54,7 @@ async function main() {
     process.exit(0);
   }
 
-  logTable(pendingProposals, [
-    'chain',
-    'nonce',
-    'submissionDate',
-    'fullTxHash',
-    'approvals',
-    'threshold',
-    'status',
-    'balance',
-  ]);
+  logProposals(pendingProposals);
 
   process.exit(0);
 }

typescript/infra/scripts/squads/parse-txs.ts

@@ -0,0 +1,98 @@
+import chalk from 'chalk';
+import yargs from 'yargs';
+
+import {
+  LogFormat,
+  LogLevel,
+  configureRootLogger,
+  rootLogger,
+} from '@hyperlane-xyz/utils';
+
+import { squadsConfigs } from '../../src/config/squads.js';
+import {
+  SquadsTransaction,
+  SquadsTransactionReader,
+} from '../../src/tx/squads-transaction-reader.js';
+import { processGovernorReaderResult } from '../../src/tx/utils.js';
+import {
+  getPendingProposalsForChains,
+  logProposals,
+} from '../../src/utils/squads.js';
+import { withChains } from '../agent-utils.js';
+import { getEnvironmentConfig } from '../core-utils.js';
+
+const environment = 'mainnet3';
+
+async function main() {
+  const { chains } = await withChains(
+    yargs(process.argv.slice(2)),
+    Object.keys(squadsConfigs),
+  ).argv;
+  configureRootLogger(LogFormat.Pretty, LogLevel.Info);
+
+  // Get the multiprovider for the environment
+  const config = getEnvironmentConfig(environment);
+  const mpp = await config.getMultiProtocolProvider();
+
+  // Initialize the transaction reader
+  const reader = new SquadsTransactionReader(environment, mpp);
+
+  // Get the pending proposals for the relevant chains
+  const chainsToCheck =
+    !chains || chains.length === 0 ? Object.keys(squadsConfigs) : chains;
+
+  const pendingProposals = await getPendingProposalsForChains(
+    chainsToCheck,
+    mpp,
+  );
+
+  if (pendingProposals.length === 0) {
+    rootLogger.info(chalk.green('No pending proposals found!'));
+    process.exit(0);
+  }
+
+  logProposals(pendingProposals);
+
+  // Parse each proposal and collect results
+  const chainResultEntries = await Promise.all(
+    pendingProposals.map(
+      async ({
+        chain,
+        nonce,
+        fullTxHash,
+      }): Promise<[string, SquadsTransaction]> => {
+        rootLogger.info(
+          chalk.gray.italic(
+            `Parsing proposal ${nonce} (${fullTxHash}) on ${chain}...`,
+          ),
+        );
+
+        try {
+          const result = await reader.read(chain, nonce);
+          rootLogger.info(
+            chalk.blue(`Finished parsing proposal ${nonce} on ${chain}`),
+          );
+          return [`${chain}-${nonce}-${fullTxHash}`, result];
+        } catch (error) {
+          rootLogger.error(
+            chalk.red(`Error parsing proposal ${nonce} on ${chain}:`),
+            error,
+          );
+          return [`${chain}-${nonce}-${fullTxHash}`, { chain, error }];
+        }
+      },
+    ),
+  );
+
+  // Process results and write to file
+  processGovernorReaderResult(
+    chainResultEntries,
+    reader.errors,
+    'squads-tx-parse-results',
+  );
+}
+
+main().catch((err) => {
+  rootLogger.error('Error:', err);
+  process.exit(1);
+});