@0xsequence/catapult 1.4.0 → 1.5.0

package/src/commands/list.ts

@@ -1,262 +0,0 @@
-import { Command } from 'commander'
-import chalk from 'chalk'
-import * as path from 'path'
-import { loadProject, projectOption, noStdOption, verbosityOption } from './common'
-import { loadNetworks } from '../lib/network-loader'
-import { setVerbosity } from '../index'
-
-interface ListOptions {
-  project: string
-  std: boolean
-  verbose: number
-}
-
-interface NetworksListOptions {
-  project: string
-  verbose: number
-  onlyTestnets?: boolean
-  onlyNonTestnets?: boolean
-}
-
-function formatSourceProvenance(provenance: { repo: string; commit?: string; ref?: string; build?: string }): string {
-  const ref = provenance.commit || provenance.ref
-  const suffix = ref ? ` @ ${ref}` : ''
-  const build = provenance.build ? ` (${provenance.build})` : ''
-  return `${provenance.repo}${suffix}${build}`
-}
-
-export function makeListCommand(): Command {
-  const list = new Command('list')
-    .description('List project resources like jobs, contracts, and networks')
-
-  const listJobs = new Command('jobs')
-    .description('List all available jobs in the project')
-  projectOption(listJobs)
-  noStdOption(listJobs)
-  verbosityOption(listJobs)
-  listJobs.action(async (options: ListOptions) => {
-    try {
-      // Set verbosity level for logging
-      setVerbosity(options.verbose as 0 | 1 | 2 | 3)
-      const loader = await loadProject(options.project, {
-        loadStdTemplates: options.std !== false
-      })
-      console.log(chalk.bold.underline('Available Jobs:'))
-      if (loader.jobs.size === 0) {
-        console.log(chalk.yellow('No jobs found in this project.'))
-        return
-      }
-      for (const job of loader.jobs.values()) {
-        const deprecatedMark = (job as { deprecated?: boolean }).deprecated ? ` ${chalk.yellow('(deprecated)')}` : ''
-        console.log(`- ${chalk.cyan(job.name)} (v${job.version})${deprecatedMark}`)
-        if (job.description) {
-          console.log(`  ${chalk.gray(job.description)}`)
-        }
-      }
-    } catch (error) {
-      console.error(chalk.red('Error listing jobs:'), error instanceof Error ? error.message : String(error))
-      process.exit(1)
-    }
-  })
-
-  const listContracts = new Command('contracts')
-    .description('List all contracts found in the project')
-  projectOption(listContracts)
-  noStdOption(listContracts)
-  verbosityOption(listContracts)
-  listContracts.action(async (options: ListOptions) => {
-    try {
-      // Set verbosity level for logging
-      setVerbosity(options.verbose as 0 | 1 | 2 | 3)
-      const loader = await loadProject(options.project, {
-        loadStdTemplates: options.std !== false
-      })
-      const contracts = loader.contractRepository.getAll()
-      const ambiguousRefs = loader.contractRepository.getAmbiguousReferences()
-
-      // Display contracts
-      console.log(chalk.bold.underline('Available Contracts:'))
-      if (contracts.length === 0) {
-        console.log(chalk.yellow('No contracts found in this project.'))
-      } else {
-        for (const contract of contracts) {
-          const name = contract.contractName || 'Unknown'
-          const source = contract.sourceName || 'Unknown'
-          console.log(`- ${chalk.cyan(name)} (${source})`)
-          console.log(`  ${chalk.gray('Unique Hash:')} ${contract.uniqueHash}`)
-          if (contract.buildInfoId) {
-            console.log(`  ${chalk.gray('Build Info ID:')} ${contract.buildInfoId}`)
-          }
-          if (contract._sourceProvenance && contract._sourceProvenance.size > 0) {
-            for (const [buildInfoPath, provenance] of contract._sourceProvenance.entries()) {
-              const relativeBuildInfoPath = path.relative(options.project, buildInfoPath)
-              console.log(`  ${chalk.gray('Provenance:')} ${formatSourceProvenance(provenance)} ${chalk.gray(`[${relativeBuildInfoPath}]`)}`)
-            }
-          }
-          console.log(`  ${chalk.gray('Sources:')} ${Array.from(contract._sources).map(p => path.relative(options.project, p)).join(', ')}`)
-        }
-      }
-
-      // Display ambiguous references if any
-      if (ambiguousRefs.length > 0) {
-        console.log('\n' + chalk.bold.underline(chalk.yellow('Ambiguous References:')))
-        console.log(chalk.yellow('The following references point to multiple contracts:'))
-        for (const ref of ambiguousRefs) {
-          console.log(`- ${chalk.red(ref)}`)
-        }
-        console.log(chalk.yellow('Use the unique hash or a more specific path to reference these contracts.'))
-      }
-
-      if (contracts.length === 0) {
-        console.log('\n' + chalk.yellow('No contracts found in this project. Make sure you have artifact files or build-info files in your project.'))
-      }
-    } catch (error) {
-      console.error(chalk.red('Error listing contracts:'), error instanceof Error ? error.message : String(error))
-      process.exit(1)
-    }
-  })
-
-  const listTemplates = new Command('templates')
-    .description('List all available templates')
-  projectOption(listTemplates)
-  noStdOption(listTemplates)
-  verbosityOption(listTemplates)
-  listTemplates.action(async (options: ListOptions) => {
-    try {
-      // Set verbosity level for logging
-      setVerbosity(options.verbose as 0 | 1 | 2 | 3)
-      const loader = await loadProject(options.project, {
-        loadStdTemplates: options.std !== false
-      })
-      console.log(chalk.bold.underline('Available Templates:'))
-      if (loader.templates.size === 0) {
-        console.log(chalk.yellow('No templates found.'))
-        return
-      }
-      for (const template of loader.templates.values()) {
-        console.log(`- ${chalk.cyan(template.name)}`)
-        if (template.description) {
-          console.log(`  ${chalk.gray(template.description)}`)
-        }
-      }
-    } catch (error) {
-      console.error(chalk.red('Error listing templates:'), error instanceof Error ? error.message : String(error))
-      process.exit(1)
-    }
-  })
-
-  const listNetworks = new Command('networks')
-    .description('List all configured networks')
-  projectOption(listNetworks)
-  verbosityOption(listNetworks)
-  listNetworks.option('--only-testnets', 'Show only test networks')
-  listNetworks.option('--only-non-testnets', 'Show only non-test networks')
-  listNetworks.option('--simple', 'Output only network names, one per line')
-  listNetworks.option('--simple-chain-ids', 'Output only chain IDs, one per line')
-  listNetworks.action(async (options: NetworksListOptions & { simple?: boolean; simpleChainIds?: boolean }) => {
-    try {
-      // Set verbosity level for logging
-      setVerbosity(options.verbose as 0 | 1 | 2 | 3)
-      const networks = await loadNetworks(options.project)
-      
-      // Apply filtering if specified
-      let filteredNetworks = networks
-      if (options.onlyTestnets) {
-        filteredNetworks = networks.filter(network => network.testnet === true)
-      } else if (options.onlyNonTestnets) {
-        filteredNetworks = networks.filter(network => network.testnet !== true)
-      }
-      
-      // Handle simple output formats
-      if (options.simple) {
-        if (filteredNetworks.length === 0) {
-          console.log('')
-          return
-        }
-        console.log(filteredNetworks.map(network => network.name).join('\n'))
-        return
-      }
-      
-      if (options.simpleChainIds) {
-        if (filteredNetworks.length === 0) {
-          console.log('')
-          return
-        }
-        console.log(filteredNetworks.map(network => network.chainId.toString()).join('\n'))
-        return
-      }
-      
-      // Default formatted output
-      console.log(chalk.bold.underline('Available Networks:'))
-      if (filteredNetworks.length === 0) {
-        if (options.onlyTestnets) {
-          console.log(chalk.yellow('No test networks configured.'))
-        } else if (options.onlyNonTestnets) {
-          console.log(chalk.yellow('No non-test networks configured.'))
-        } else {
-          console.log(chalk.yellow('No networks configured. Create a networks.yaml file in your project root.'))
-        }
-        return
-      }
-      
-      for (const network of filteredNetworks) {
-        const testnetIndicator = network.testnet ? chalk.green('(testnet)') : ''
-        console.log(`- ${chalk.cyan(network.name)} (Chain ID: ${network.chainId}) ${testnetIndicator}`)
-        console.log(`  ${chalk.gray(`RPC: ${network.rpcUrl}`)}`)
-      }
-    } catch (error) {
-      console.error(chalk.red('Error listing networks:'), error instanceof Error ? error.message : String(error))
-      process.exit(1)
-    }
-  })
-
-  // New: list constants
-  const listConstants = new Command('constants')
-    .description('List constants defined at top-level and per job')
-  projectOption(listConstants)
-  noStdOption(listConstants)
-  verbosityOption(listConstants)
-  listConstants.action(async (options: ListOptions) => {
-    try {
-      setVerbosity(options.verbose as 0 | 1 | 2 | 3)
-      const loader = await loadProject(options.project, {
-        loadStdTemplates: options.std !== false
-      })
-      console.log(chalk.bold.underline('Top-level Constants:'))
-      if (loader.constants.size === 0) {
-        console.log(chalk.yellow('No top-level constants found.'))
-      } else {
-        for (const [key, value] of loader.constants.entries()) {
-          // Only display keys to avoid dumping large values
-          console.log(`- ${chalk.cyan(key)}${options.verbose ? ` = ${JSON.stringify(value)}` : ''}`)
-        }
-      }
-      console.log(chalk.bold.underline('\nJob-level Constants:'))
-      let anyJobConstants = false
-      for (const job of loader.jobs.values()) {
-        const constants = job.constants
-        if (constants && Object.keys(constants).length > 0) {
-          anyJobConstants = true
-          console.log(`- ${chalk.cyan(job.name)}:`)
-          for (const key of Object.keys(constants)) {
-            console.log(`  • ${key}${options.verbose ? ` = ${JSON.stringify(constants[key])}` : ''}`)
-          }
-        }
-      }
-      if (!anyJobConstants) {
-        console.log(chalk.yellow('No job-level constants found.'))
-      }
-    } catch (error) {
-      console.error(chalk.red('Error listing constants:'), error instanceof Error ? error.message : String(error))
-      process.exit(1)
-    }
-  })
-
-  list.addCommand(listJobs)
-  list.addCommand(listContracts)
-  list.addCommand(listTemplates)
-  list.addCommand(listNetworks)
-  list.addCommand(listConstants)
-
-  return list
-}

package/src/commands/provenance.ts

@@ -1,120 +0,0 @@
-import { Command } from 'commander'
-import chalk from 'chalk'
-import * as path from 'path'
-import { projectOption, noStdOption, verbosityOption } from './common'
-import { setVerbosity } from '../index'
-import {
-  generateBuildInfoFromSourceProvenance,
-  ProvenanceOperationResult,
-  ProvenanceRunResult,
-  verifySourceProvenance
-} from '../lib/provenance'
-
-interface ProvenanceOptions {
-  project: string
-  std: boolean
-  verbose: number
-  includeDependencies?: boolean
-  force?: boolean
-}
-
-export function makeProvenanceCommand(): Command {
-  const provenance = new Command('provenance')
-    .description('Work with build-info source provenance')
-
-  const verify = new Command('verify')
-    .description('Verify committed build-info files against source provenance')
-    .argument('[jobs...]', 'Optional job names or patterns to verify. Without jobs, verifies all provenance in the project.')
-    .option('--include-dependencies', 'When jobs are provided, include their dependency jobs too.', false)
-  projectOption(verify)
-  noStdOption(verify)
-  verbosityOption(verify)
-  verify.action(async (jobs: string[], options: ProvenanceOptions) => {
-    try {
-      setVerbosity(options.verbose as 0 | 1 | 2 | 3)
-      const result = await verifySourceProvenance(options.project, {
-        jobs,
-        includeDependencies: options.includeDependencies === true,
-        loadStdTemplates: options.std !== false
-      })
-      printRunResult('verify', options.project, result)
-      exitIfFailed(result)
-    } catch (error) {
-      console.error(chalk.red('Error verifying provenance:'), error instanceof Error ? error.message : String(error))
-      process.exit(1)
-    }
-  })
-
-  const generate = new Command('generate')
-    .description('Generate missing build-info files from source provenance')
-    .argument('[jobs...]', 'Optional job names or patterns to generate. Without jobs, generates for all provenance in the project.')
-    .option('--include-dependencies', 'When jobs are provided, include their dependency jobs too.', false)
-    .option('--force', 'Overwrite existing build-info files.', false)
-  projectOption(generate)
-  noStdOption(generate)
-  verbosityOption(generate)
-  generate.action(async (jobs: string[], options: ProvenanceOptions) => {
-    try {
-      setVerbosity(options.verbose as 0 | 1 | 2 | 3)
-      const result = await generateBuildInfoFromSourceProvenance(options.project, {
-        jobs,
-        includeDependencies: options.includeDependencies === true,
-        loadStdTemplates: options.std !== false,
-        force: options.force === true
-      })
-      printRunResult('generate', options.project, result)
-      exitIfFailed(result)
-    } catch (error) {
-      console.error(chalk.red('Error generating build-info from provenance:'), error instanceof Error ? error.message : String(error))
-      process.exit(1)
-    }
-  })
-
-  provenance.addCommand(verify)
-  provenance.addCommand(generate)
-  return provenance
-}
-
-function printRunResult(command: 'verify' | 'generate', projectRoot: string, result: ProvenanceRunResult): void {
-  for (const warning of result.warnings) {
-    console.warn(chalk.yellow(warning))
-  }
-
-  if (result.entries.length === 0) {
-    console.log(chalk.yellow('No source provenance entries found.'))
-    return
-  }
-
-  for (const item of result.results) {
-    printOperationResult(projectRoot, item)
-  }
-
-  const failed = result.results.filter(item => item.status === 'failed').length
-  const skipped = result.results.filter(item => item.status === 'skipped').length
-  const completed = result.results.length - failed - skipped
-  const verb = command === 'verify' ? 'verified' : 'generated'
-
-  if (failed > 0) {
-    console.log(chalk.red(`Provenance ${command} completed with ${failed} failure(s), ${completed} ${verb}, ${skipped} skipped.`))
-  } else {
-    console.log(chalk.green(`Provenance ${command} completed: ${completed} ${verb}, ${skipped} skipped.`))
-  }
-}
-
-function printOperationResult(projectRoot: string, result: ProvenanceOperationResult): void {
-  const target = path.relative(projectRoot, result.entry.buildInfoPath)
-  const source = path.relative(projectRoot, result.entry.sourceDocumentPath)
-  const prefix = result.status === 'failed'
-    ? chalk.red('failed')
-    : result.status === 'skipped'
-      ? chalk.yellow('skipped')
-      : chalk.green(result.status)
-
-  console.log(`${prefix} ${target} ${chalk.gray(`[${source}]`)} - ${result.message}`)
-}
-
-function exitIfFailed(result: ProvenanceRunResult): void {
-  if (result.results.some(item => item.status === 'failed')) {
-    process.exit(1)
-  }
-}

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
-}