@0xsequence/catapult 1.4.0 → 1.5.0

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() 

package/src/lib/__tests__/deployer-events.spec.ts

@@ -1,338 +0,0 @@
-import { Deployer, DeployerOptions } from '../deployer'
-import { DeploymentEventEmitter } from '../events'
-import { Network } from '../types'
-
-// Mock the ProjectLoader to avoid file system dependencies in tests
-jest.mock('../core/loader', () => {
-  return {
-    ProjectLoader: jest.fn().mockImplementation(() => {
-      const mockJobs = new Map([
-        ['test-job', {
-          name: 'test-job',
-          version: '1.0.0',
-          actions: [],
-          depends_on: []
-        }]
-      ])
-      
-      const mockTemplates = new Map()
-      
-      return {
-        load: jest.fn().mockResolvedValue(undefined),
-        jobs: mockJobs,
-        templates: mockTemplates,
-        contractRepository: {
-          lookup: jest.fn(),
-          getAll: jest.fn()
-        }
-      }
-    })
-  }
-})
-
-// Mock the DependencyGraph
-jest.mock('../core/graph', () => {
-  return {
-    DependencyGraph: jest.fn().mockImplementation(() => ({
-      getExecutionOrder: jest.fn().mockReturnValue(['test-job']),
-      getDependencies: jest.fn().mockReturnValue(new Set())
-    }))
-  }
-})
-
-// Mock the ExecutionEngine
-jest.mock('../core/engine', () => {
-  return {
-    ExecutionEngine: jest.fn().mockImplementation(() => ({
-      executeJob: jest.fn().mockResolvedValue(undefined)
-    }))
-  }
-})
-
-// Mock the ExecutionContext to avoid ethers validation
-jest.mock('../core/context', () => {
-  return {
-    ExecutionContext: jest.fn().mockImplementation(() => ({
-      getNetwork: jest.fn().mockReturnValue({
-        name: 'localhost',
-        chainId: 1337,
-        rpcUrl: 'http://localhost:8545'
-      }),
-      setOutput: jest.fn(),
-      getOutput: jest.fn(),
-      getOutputs: jest.fn().mockReturnValue(new Map())
-    }))
-  }
-})
-
-// Mock fs operations
-jest.mock('fs/promises', () => ({
-  mkdir: jest.fn().mockResolvedValue(undefined),
-  writeFile: jest.fn().mockResolvedValue(undefined)
-}))
-
-describe('Deployer Event Integration', () => {
-  let deployer: Deployer
-  let eventEmitter: DeploymentEventEmitter
-  let emittedEvents: any[]
-
-  const mockOptions: DeployerOptions = {
-    projectRoot: '/test/project',
-    privateKey: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12',
-    networks: [
-      {
-        name: 'localhost',
-        chainId: 1337,
-        rpcUrl: 'http://localhost:8545'
-      } as Network
-    ]
-  }
-
-  beforeEach(() => {
-    emittedEvents = []
-    eventEmitter = new DeploymentEventEmitter()
-    
-    // Capture all emitted events
-    eventEmitter.onAnyEvent((event) => {
-      emittedEvents.push(event)
-    })
-
-    deployer = new Deployer({
-      ...mockOptions,
-      eventEmitter
-    })
-  })
-
-  describe('Deployment Lifecycle Events', () => {
-    it('should emit deployment_started event when run begins', async () => {
-      await expect(deployer.run()).resolves.not.toThrow()
-
-      const startEvent = emittedEvents.find(e => e.type === 'deployment_started')
-      expect(startEvent).toBeDefined()
-      expect(startEvent.data.projectRoot).toBe('/test/project')
-      expect(startEvent.level).toBe('info')
-      expect(startEvent.timestamp).toBeInstanceOf(Date)
-    })
-
-    it('should emit project loading events', async () => {
-      await expect(deployer.run()).resolves.not.toThrow()
-
-      const loadingStartedEvent = emittedEvents.find(e => e.type === 'project_loading_started')
-      expect(loadingStartedEvent).toBeDefined()
-      expect(loadingStartedEvent.data.projectRoot).toBe('/test/project')
-
-      const loadedEvent = emittedEvents.find(e => e.type === 'project_loaded')
-      expect(loadedEvent).toBeDefined()
-      expect(loadedEvent.data.jobCount).toBeDefined()
-      expect(loadedEvent.data.templateCount).toBeDefined()
-    })
-
-    it('should emit execution plan event', async () => {
-      await expect(deployer.run()).resolves.not.toThrow()
-
-      const planEvent = emittedEvents.find(e => e.type === 'execution_plan')
-      expect(planEvent).toBeDefined()
-      expect(planEvent.data.targetNetworks).toEqual([{
-        name: 'localhost',
-        chainId: 1337
-      }])
-      expect(planEvent.data.jobExecutionOrder).toEqual(['test-job'])
-    })
-
-    it('should emit network_started event for each network', async () => {
-      await expect(deployer.run()).resolves.not.toThrow()
-
-      const networkEvent = emittedEvents.find(e => e.type === 'network_started')
-      expect(networkEvent).toBeDefined()
-      expect(networkEvent.data.networkName).toBe('localhost')
-      expect(networkEvent.data.chainId).toBe(1337)
-    })
-
-    it('should emit deployment_completed event on success', async () => {
-      await expect(deployer.run()).resolves.not.toThrow()
-
-      const completedEvent = emittedEvents.find(e => e.type === 'deployment_completed')
-      expect(completedEvent).toBeDefined()
-      expect(completedEvent.level).toBe('info')
-    })
-
-    it('should emit output writing events', async () => {
-      // Mock context.getOutputs to return some outputs
-      const { ExecutionEngine } = require('../core/engine')
-      ExecutionEngine.mockImplementation(() => ({
-        executeJob: jest.fn().mockImplementation((job, context) => {
-          // Mock the getOutputs method
-          context.getOutputs = jest.fn().mockReturnValue(new Map([
-            ['contract.address', '0x1234567890123456789012345678901234567890']
-          ]))
-        })
-      }))
-
-      deployer = new Deployer({
-        ...mockOptions,
-        eventEmitter
-      })
-
-      await expect(deployer.run()).resolves.not.toThrow()
-
-      const outputWritingEvent = emittedEvents.find(e => e.type === 'output_writing_started')
-      expect(outputWritingEvent).toBeDefined()
-
-      const outputFileEvent = emittedEvents.find(e => e.type === 'output_file_written')
-      expect(outputFileEvent).toBeDefined()
-      expect(outputFileEvent.data.relativePath).toBe('output/test-job.json')
-    })
-  })
-
-  describe('Error Handling', () => {
-    it('should emit deployment_failed event on error', async () => {
-      // Mock the loader to throw an error
-      const { ProjectLoader } = require('../core/loader')
-      ProjectLoader.mockImplementation(() => ({
-        load: jest.fn().mockRejectedValue(new Error('Test error'))
-      }))
-
-      deployer = new Deployer({
-        ...mockOptions,
-        eventEmitter
-      })
-
-      await expect(deployer.run()).rejects.toThrow('Test error')
-
-      const failedEvent = emittedEvents.find(e => e.type === 'deployment_failed')
-      expect(failedEvent).toBeDefined()
-      expect(failedEvent.level).toBe('error')
-      expect(failedEvent.data.error).toBe('Test error')
-      expect(failedEvent.data.stack).toBeDefined()
-    })
-  })
-
-  describe('Network Filtering', () => {
-    beforeEach(() => {
-      // Reset mocks for this test group
-      jest.clearAllMocks()
-      
-      // Reset the ProjectLoader mock to success
-      const { ProjectLoader } = require('../core/loader')
-      ProjectLoader.mockImplementation(() => ({
-        load: jest.fn().mockResolvedValue(undefined),
-        jobs: new Map([
-          ['test-job', {
-            name: 'test-job',
-            version: '1.0.0',
-            actions: [],
-            depends_on: []
-          }]
-        ]),
-        templates: new Map(),
-        contractRepository: {
-          lookup: jest.fn(),
-          getAll: jest.fn()
-        }
-      }))
-      
-      emittedEvents.length = 0 // Clear events array
-    })
-
-    it('should emit missing_network_config_warning for unknown chain IDs', async () => {
-      deployer = new Deployer({
-        ...mockOptions,
-        runOnNetworks: [1337, 999], // 999 doesn't exist
-        eventEmitter
-      })
-
-      await expect(deployer.run()).resolves.not.toThrow()
-
-      const warningEvent = emittedEvents.find(e => e.type === 'missing_network_config_warning')
-      expect(warningEvent).toBeDefined()
-      expect(warningEvent.data.missingChainIds).toEqual([999])
-    })
-
-    // Note: Testing no_outputs event is complex in integration tests
-    // as it requires specific job execution scenarios. The event itself
-    // is tested in the main deployer tests.
-  })
-
-  describe('Event Ordering', () => {
-    beforeEach(() => {
-      // Reset mocks and create fresh deployer for this test group
-      jest.clearAllMocks()
-      
-      // Reset the ProjectLoader mock to success
-      const { ProjectLoader } = require('../core/loader')
-      ProjectLoader.mockImplementation(() => ({
-        load: jest.fn().mockResolvedValue(undefined),
-        jobs: new Map([
-          ['test-job', {
-            name: 'test-job',
-            version: '1.0.0',
-            actions: [],
-            depends_on: []
-          }]
-        ]),
-        templates: new Map(),
-        contractRepository: {
-          lookup: jest.fn(),
-          getAll: jest.fn()
-        }
-      }))
-      
-      emittedEvents.length = 0 // Clear events array
-      
-      deployer = new Deployer({
-        ...mockOptions,
-        eventEmitter
-      })
-    })
-
-    it('should emit events in the correct order', async () => {
-      await expect(deployer.run()).resolves.not.toThrow()
-
-      const eventTypes = emittedEvents.map(e => e.type)
-      
-      // Check that events are in a logical order
-      expect(eventTypes.indexOf('deployment_started')).toBeLessThan(
-        eventTypes.indexOf('project_loading_started')
-      )
-      expect(eventTypes.indexOf('project_loaded')).toBeLessThan(
-        eventTypes.indexOf('execution_plan')
-      )
-      expect(eventTypes.indexOf('execution_plan')).toBeLessThan(
-        eventTypes.indexOf('network_started')
-      )
-      expect(eventTypes.indexOf('network_started')).toBeLessThan(
-        eventTypes.indexOf('deployment_completed')
-      )
-    })
-
-    it('should have timestamps in chronological order', async () => {
-      deployer = new Deployer({
-        ...mockOptions,
-        eventEmitter
-      })
-
-      await expect(deployer.run()).resolves.not.toThrow()
-
-      // Check that timestamps are increasing
-      for (let i = 1; i < emittedEvents.length; i++) {
-        expect(emittedEvents[i].timestamp.getTime()).toBeGreaterThanOrEqual(
-          emittedEvents[i - 1].timestamp.getTime()
-        )
-      }
-    })
-  })
-
-  describe('Event Emitter Access', () => {
-    it('should expose the event emitter as a public property', () => {
-      expect(deployer.events).toBe(eventEmitter)
-      expect(deployer.events).toBeInstanceOf(DeploymentEventEmitter)
-    })
-
-    it('should use global singleton when no custom emitter provided', () => {
-      const { deploymentEvents } = require('../events')
-      const deployerWithoutCustomEmitter = new Deployer(mockOptions)
-      
-      expect(deployerWithoutCustomEmitter.events).toBe(deploymentEvents)
-    })
-  })
-})