@0xsequence/catapult 1.3.17 → 1.5.0

package/src/commands/run.ts

@@ -1,146 +0,0 @@
-import { Command } from 'commander'
-import { Deployer, DeployerOptions } from '../lib/deployer'
-import { loadNetworks } from '../lib/network-loader'
-import { detectNetworkFromRpc, isValidRpcUrl } from '../lib/network-utils'
-import { Network } from '../lib/types'
-import { deploymentEvents } from '../lib/events'
-import { projectOption, dotenvOption, noStdOption, verbosityOption, loadDotenv } from './common'
-import { resolveSelectedChainIds } from '../lib/network-selection'
-import { setVerbosity } from '../index'
-
-interface RunOptions {
-  project: string
-  privateKey?: string
-  network?: string
-  rpcUrl?: string
-  dotenv?: string
-  std: boolean
-  etherscanApiKey?: string
-  verbose: number
-  failEarly: boolean
-  noPostCheckConditions: boolean
-  flatOutput: boolean
-  summary: boolean
-  ignoreVerifyErrors: boolean
-}
- 
-export function makeRunCommand(): Command {
-  const run = new Command('run')
-    .description('Run deployment jobs on specified networks')
-    .argument('[jobs...]', 'Specific job names or patterns to run (and their dependencies). Supports wildcards like "sequence/*" or "job?". If not provided, all jobs are run.')
-    .option('-k, --private-key <key>', 'Signer private key. Can also be set via PRIVATE_KEY env var.')
-    .option('-n, --network <selectors>', 'Comma-separated network selectors (by chain ID or name). If not provided, runs on all configured networks.')
-    .option('--rpc-url <url>', 'Custom RPC URL to run on. The system will automatically detect chainId and network information. This overrides networks.yaml configuration.')
-    .option('--etherscan-api-key <key>', 'Etherscan API key for contract verification. Can also be set via ETHERSCAN_API_KEY env var.')
-    .option('--fail-early', 'Stop execution as soon as any job fails. Default: false', false)
-    .option('--no-post-check-conditions', 'Skip post-execution check of skip conditions. Default: false (post-check enabled)', false)
-    .option('--flat-output', 'Write output files in a single flat directory instead of mirroring the jobs directory structure. Default: false', false)
-    .option('--no-summary', 'Hide final summary at the end of the run. Default: show', false)
-    .option('--run-deprecated', 'Allow running jobs marked as deprecated. By default deprecated jobs are skipped unless explicitly targeted.', false)
-    .option('--ignore-verify-errors', 'Convert verification errors to warnings instead of exiting with error code. Shows complete warning report at the end.', false)
-
-  projectOption(run)
-  dotenvOption(run)
-  noStdOption(run)
-  verbosityOption(run)
-
-  run.action(async (jobs: string[], options: RunOptions) => {
-    try {
-      loadDotenv(options)
-      
-      // Set verbosity level for logging
-      setVerbosity(options.verbose as 0 | 1 | 2 | 3)
-      
-      const privateKey: string | undefined = options.privateKey || process.env.PRIVATE_KEY
-      if (!privateKey && !options.rpcUrl) {
-        throw new Error('A private key must be provided via the --private-key option or the PRIVATE_KEY environment variable, or an --rpc-url must be specified to attempt an implicit sender.')
-      }
-
-      const etherscanApiKey = options.etherscanApiKey || process.env.ETHERSCAN_API_KEY
-
-      const projectRoot = options.project
-      
-      // Load networks from YAML file
-      let networks = await loadNetworks(projectRoot)
-      
-      // Handle custom RPC URL if provided
-      if (options.rpcUrl) {
-        // Custom RPC URL provided
-        
-        // Validate RPC URL format
-        if (!isValidRpcUrl(options.rpcUrl)) {
-          throw new Error(`Invalid RPC URL format: ${options.rpcUrl}`)
-        }
-        
-        try {
-          // Detect network information from RPC URL
-          const detectedNetwork = await detectNetworkFromRpc(options.rpcUrl)
-          
-          // Try to find a matching network in networks.yaml by chainId to merge verification platform support
-          const knownNetwork = networks.find(n => n.chainId === detectedNetwork.chainId)
-
-          // Create a complete network object, merging with known network config if found
-          const customNetwork: Network = {
-            name: detectedNetwork.name || knownNetwork?.name || `custom-${detectedNetwork.chainId}`,
-            chainId: detectedNetwork.chainId!,
-            rpcUrl: options.rpcUrl,
-            // Optional fields with defaults
-            supports: detectedNetwork.supports || knownNetwork?.supports || [],
-            gasLimit: detectedNetwork.gasLimit || knownNetwork?.gasLimit,
-            testnet: detectedNetwork.testnet !== undefined ? detectedNetwork.testnet : knownNetwork?.testnet,
-            evmVersion: detectedNetwork.evmVersion || knownNetwork?.evmVersion,
-            params: detectedNetwork.params || knownNetwork?.params,
-          }
-          
-          // Custom network created from RPC detection
-          
-          // Replace networks array with just the custom network
-          networks = [customNetwork]
-        } catch (error) {
-          throw new Error(`Failed to detect network from RPC URL "${options.rpcUrl}": ${error instanceof Error ? error.message : String(error)}`)
-        }
-      }
-
-      if (networks.length === 0 && !options.rpcUrl) {
-        throw new Error('No networks configured. Please create a networks.yaml file in your project root or use --rpc-url to specify a custom network.')
-      }
-
-      const selectedChainIds = resolveSelectedChainIds(options.network, networks)
-      const deployerOptions: DeployerOptions = {
-        projectRoot,
-        privateKey,
-        networks,
-        runJobs: jobs.length > 0 ? jobs : undefined,
-        runOnNetworks: selectedChainIds,
-        etherscanApiKey,
-        failEarly: options.failEarly,
-        noPostCheckConditions: options.noPostCheckConditions,
-        showSummary: options.summary !== false,
-        loaderOptions: {
-          loadStdTemplates: options.std !== false
-        },
-        flatOutput: options.flatOutput === true,
-        runDeprecated: (options as { runDeprecated?: boolean }).runDeprecated === true,
-        ignoreVerifyErrors: options.ignoreVerifyErrors === true
-      } as DeployerOptions
-
-      const deployer = new Deployer(deployerOptions)
-      await deployer.run()
-
-    } catch (error) {
-      // The deployer emits its own rich error event, so we just log a generic one if something fails before that.
-      if (!(error instanceof Error && error.message.includes('deployment_failed'))) {
-        deploymentEvents.emitEvent({
-          type: 'cli_error',
-          level: 'error',
-          data: {
-            message: error instanceof Error ? error.message : String(error)
-          }
-        })
-      }
-      process.exit(1)
-    }
-  })
-
-  return run
-}

package/src/commands/utils.ts

@@ -1,215 +0,0 @@
-import { Command } from 'commander'
-import chalk from 'chalk'
-import * as fs from 'fs'
-import * as path from 'path'
-import { projectOption, verbosityOption } from './common'
-import { loadNetworks } from '../lib/network-loader'
-import { setVerbosity } from '../index'
-
-interface UtilsOptions {
-  project: string
-  verbose: number
-}
-
-export function makeUtilsCommand(): Command {
-  const utils = new Command('utils')
-    .description('Utility commands for project management')
-
-  const chainIdToName = new Command('chain-id-to-name')
-    .description('Convert a chain ID to network name')
-  projectOption(chainIdToName)
-  verbosityOption(chainIdToName)
-
-  chainIdToName.argument('<chain-id>', 'The chain ID to convert')
-  chainIdToName.action(async (chainId: string, options: UtilsOptions) => {
-    try {
-      // Set verbosity level for logging
-      setVerbosity(options.verbose as 0 | 1 | 2 | 3)
-      
-      const chainIdNumber = parseInt(chainId, 10)
-      if (isNaN(chainIdNumber)) {
-        console.error(chalk.red('Invalid chain ID. Please provide a valid number.'))
-        process.exit(1)
-      }
-
-      const networks = await loadNetworks(options.project)
-      
-      const network = networks.find(n => n.chainId === chainIdNumber)
-      
-      if (network) {
-        console.log(network.name)
-      } else {
-        console.error(chalk.red(`No network found with chain ID ${chainIdNumber}`))
-        process.exit(1)
-      }
-    } catch (error) {
-      console.error(chalk.red('Error converting chain ID to network name:'), error instanceof Error ? error.message : String(error))
-      process.exit(1)
-    }
-  })
-
-  utils.addCommand(chainIdToName)
-
-  // utils gen-table <output-dir>
-  const genTable = new Command('gen-table')
-    .description('Generate a consolidated addresses table from an output directory')
-    .argument('<output-dir>', 'Directory containing job output JSON files (searches recursively)')
-    .option('--name', 'Include Name column', true)
-    .option('--key', 'Include Key column', false)
-    .option('--file', 'Include File column', false)
-    .option('--chain-ids, --chainIds', 'Include ChainIds column', false)
-    .option('--job', 'Include Job column', true)
-    .option('--address', 'Include Address column', true)
-    .option('--format <format>', "Output format: 'markdown' or 'ascii' (default)", 'ascii')
-    .action(async (outputDir: string, options: { name?: boolean; key?: boolean; file?: boolean; chainIds?: boolean; job?: boolean; address?: boolean; format?: string }) => {
-      try {
-        const absoluteDir = path.resolve(outputDir)
-        if (!fs.existsSync(absoluteDir) || !fs.statSync(absoluteDir).isDirectory()) {
-          console.error(chalk.red(`Output directory not found or not a directory: ${absoluteDir}`))
-          process.exit(1)
-        }
-
-        const jsonFiles: string[] = []
-        const walk = (dir: string) => {
-          for (const entry of fs.readdirSync(dir)) {
-            const full = path.join(dir, entry)
-            const stat = fs.statSync(full)
-            if (stat.isDirectory()) walk(full)
-            else if (stat.isFile() && entry.toLowerCase().endsWith('.json')) jsonFiles.push(full)
-          }
-        }
-        walk(absoluteDir)
-
-        type Row = { job: string; chainIds: string; name: string; address: string; key: string; file: string }
-        const rows: Row[] = []
-        const addressRegex = /^0x[a-fA-F0-9]{40}$/
-
-        const toTitleCase = (slug: string): string => slug.split(/[-_\s]+/).filter(Boolean).map(s => s.charAt(0).toUpperCase() + s.slice(1)).join('')
-        const extractVersionSuffix = (jobName: string): string => {
-          const m = jobName.match(/[-_]?v(\d+)/i)
-          return m ? `V${m[1]}` : ''
-        }
-        const deriveName = (jobName: string, key: string): string => {
-          const version = extractVersionSuffix(jobName)
-          const baseJob = jobName.replace(/[-_]?v\d+$/i, '')
-          const keyCore = key.replace(/\.address$/i, '')
-          // Prefer descriptive key name; if too generic like 'factory', prefix with job base
-          const isGeneric = /^(factory|address)$/i.test(keyCore)
-          const nameCore = isGeneric ? `${toTitleCase(baseJob)} ${toTitleCase(keyCore)}` : toTitleCase(keyCore)
-          return `${nameCore.replace(/\s+/g, '')}${version}`
-        }
-
-        for (const file of jsonFiles) {
-          try {
-            const raw = fs.readFileSync(file, 'utf8')
-            const data = JSON.parse(raw)
-            if (!data || typeof data !== 'object' || !Array.isArray(data.networks)) continue
-            const jobName: string = data.jobName ?? path.basename(file, '.json')
-            for (const net of data.networks) {
-              if (!net || typeof net !== 'object') continue
-              const outputs = net.outputs as Record<string, unknown> | undefined
-              if (!outputs) continue
-              const chainIds: string[] = Array.isArray(net.chainIds) ? net.chainIds : []
-              for (const [key, value] of Object.entries(outputs)) {
-                let address: string | undefined
-                if (typeof value === 'string' && addressRegex.test(value)) {
-                  address = value
-                } else if (value && typeof value === 'object' && 'address' in value && typeof value.address === 'string' && addressRegex.test(value.address)) {
-                  address = value.address
-                }
-                if (!address) continue
-                rows.push({
-                  job: jobName,
-                  chainIds: chainIds.join(','),
-                  name: deriveName(jobName, key),
-                  address,
-                  key,
-                  file
-                })
-              }
-            }
-          } catch {
-            // skip invalid JSON
-          }
-        }
-
-        rows.sort((a, b) => a.job.localeCompare(b.job) || a.name.localeCompare(b.name))
-
-        if (rows.length === 0) {
-          console.log(chalk.yellow('No address entries found.'))
-          return
-        }
-
-        // Determine which columns to show
-        const showJob = !!options.job
-        const showAddress = !!options.address
-        const showName = !!options.name
-        const showKey = !!options.key
-        const showChainIds = !!options.chainIds
-        const showFile = !!options.file
-
-        const selectedHeaders: (keyof Row)[] = []
-        if (showJob) selectedHeaders.push('job')
-        if (showChainIds) selectedHeaders.push('chainIds')
-        if (showName) selectedHeaders.push('name')
-        if (showAddress) selectedHeaders.push('address')
-        if (showKey) selectedHeaders.push('key')
-        if (showFile) selectedHeaders.push('file')
-
-        // Titles for columns
-        const titles: Record<keyof Row, string> = {
-          job: 'Job',
-          chainIds: 'ChainIds',
-          name: 'Name',
-          address: 'Address',
-          key: 'Key',
-          file: 'File'
-        }
-        const format = String(options.format || 'markdown').toLowerCase()
-        if (format !== 'markdown' && format !== 'ascii') {
-          console.error(chalk.red("Invalid format. Use 'markdown' or 'ascii'."))
-          process.exit(1)
-        }
-
-        if (format === 'markdown') {
-          const header = '| ' + selectedHeaders.map(h => titles[h]).join(' | ') + ' |'
-          const sepMd = '| ' + selectedHeaders.map(h => '-'.repeat(Math.max(3, String(titles[h]).length))).join(' | ') + ' |'
-          console.log(header)
-          console.log(sepMd)
-          for (const r of rows) {
-            console.log('| ' + selectedHeaders.map(h => String(r[h])).join(' | ') + ' |')
-          }
-        } else {
-          // ascii rendering with box-drawing characters
-          const widths: Record<string, number> = {}
-          for (const h of selectedHeaders) {
-            widths[h] = Math.max(titles[h].length, ...rows.map(r => String(r[h]).length))
-          }
-          const makeSep = (left: string, mid: string, right: string, fill: string) => {
-            return left + selectedHeaders.map(h => fill.repeat(widths[h] + 2)).join(mid) + right
-          }
-          const pad = (s: string, w: number) => s + ' '.repeat(Math.max(0, w - s.length))
-
-          const top = makeSep('┌', '┬', '┐', '─')
-          const sep = makeSep('├', '┼', '┤', '─')
-          const bot = makeSep('└', '┴', '┘', '─')
-          const headerLine = '│' + selectedHeaders.map(h => ' ' + pad(titles[h], widths[h]) + ' ').join('│') + '│'
-          const lines = rows.map(r => '│' + selectedHeaders.map(h => ' ' + pad(String(r[h]), widths[h]) + ' ').join('│') + '│')
-
-          console.log(top)
-          console.log(headerLine)
-          console.log(sep)
-          for (const line of lines) console.log(line)
-          console.log(bot)
-        }
-
-      } catch (error) {
-        console.error(chalk.red('Error generating table:'), error instanceof Error ? error.message : String(error))
-        process.exit(1)
-      }
-    })
-
-  utils.addCommand(genTable)
-
-  return utils
-}

package/src/index.ts

@@ -1,67 +0,0 @@
-#!/usr/bin/env node
-
-import { program } from 'commander'
-import chalk from 'chalk'
-import { setupCommands } from './cli'
-import packageJson from '../package.json'
-
-import { deploymentEvents, CLIEventAdapter, VerbosityLevel } from './lib/events'
-
-// Set up CLI event adapter to convert events to console output
-const cliAdapter = new CLIEventAdapter(deploymentEvents)
-
-// Export function to update CLI verbosity
-export function setVerbosity(level: VerbosityLevel): void {
-  cliAdapter.setVerbosity(level)
-}
-
-// Setup global error handling
-process.on('unhandledRejection', (reason, promise) => {
-  deploymentEvents.emitEvent({
-    type: 'unhandled_rejection',
-    level: 'error',
-    data: {
-      reason,
-      promise
-    }
-  })
-  process.exit(1)
-})
-
-process.on('uncaughtException', (error) => {
-  deploymentEvents.emitEvent({
-    type: 'uncaught_exception',
-    level: 'error',
-    data: {
-      error
-    }
-  })
-  process.exit(1)
-})
-
-async function main() {
-  try {
-    // Configure the main program
-    program
-      .name('catapult')
-      .description('Ethereum contract deployment CLI tool')
-      .version(packageJson.version)
-
-    // Setup all commands
-    setupCommands(program)
-
-    // Parse arguments
-    await program.parseAsync(process.argv)
-  } catch (error) {
-    deploymentEvents.emitEvent({
-      type: 'cli_error',
-      level: 'error',
-      data: {
-        message: error instanceof Error ? error.message : String(error)
-      }
-    })
-    process.exit(1)
-  }
-}
-
-main()