@0xsequence/catapult 1.2.1 → 1.3.2

package/src/commands/utils.ts

@@ -1,5 +1,7 @@
 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'
@@ -48,5 +50,166 @@ export function makeUtilsCommand(): Command {
 
   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/lib/__tests__/deployer.spec.ts

@@ -1,6 +1,4 @@
 import * as fs from 'fs/promises'
-import * as path from 'path'
-import chalk from 'chalk'
 import { Deployer, DeployerOptions } from '../deployer'
 import { ProjectLoader } from '../core/loader'
 import { DependencyGraph } from '../core/graph'
@@ -174,7 +172,7 @@ describe('Deployer', () => {
         expect(mockLoader.load).toHaveBeenCalledTimes(1)
         expect(MockDependencyGraph).toHaveBeenCalledWith(mockLoader.jobs, mockLoader.templates)
         expect(mockGraph.getExecutionOrder).toHaveBeenCalledTimes(1)
-        expect(MockExecutionEngine).toHaveBeenCalledWith(mockLoader.templates, expect.any(Object), expect.any(Object), false)
+        expect(MockExecutionEngine).toHaveBeenCalledWith(mockLoader.templates, expect.any(Object))
         expect(mockEngine.executeJob).toHaveBeenCalledTimes(5) // job1&job2 on 2 networks + job3 on 1 network
         expect(MockExecutionContext).toHaveBeenCalledTimes(5)
         expect(mockFs.mkdir).toHaveBeenCalledWith('/test/project/output', { recursive: true })

package/src/lib/__tests__/network-loader.spec.ts

@@ -84,7 +84,7 @@ describe('network-loader rpcUrl token replacement', () => {
     expect(networks[0].rpcUrl).toBe('https://node.example.com/XYZ')
   })
 
-  test('throws error when RPC token has no matching env var', async () => {
+  test('defaults to empty string when RPC token has no matching env var', async () => {
     const projectRoot = path.join(tmpDir, 'case5')
     delete process.env.RPC_MISSING
     const yaml = `
@@ -94,6 +94,7 @@ describe('network-loader rpcUrl token replacement', () => {
 `
     await writeNetworksYaml(projectRoot, yaml)
 
-    await expect(loadNetworks(projectRoot)).rejects.toThrow('Environment variable RPC_MISSING is not set')
+    const networks = await loadNetworks(projectRoot)
+    expect(networks[0].rpcUrl).toBe('https://node.example.com/')
   })
 })

package/src/lib/__tests__/network-selection.spec.ts

@@ -0,0 +1,41 @@
+import { resolveSelectedChainIds, resolveSingleChainId } from '../../lib/network-selection'
+import { Network } from '../../lib/types'
+
+describe('network-selection', () => {
+  const networks: Network[] = [
+    { name: 'Mainnet', chainId: 1, rpcUrl: 'https://mainnet' },
+    { name: 'Arbitrum One', chainId: 42161, rpcUrl: 'https://arb' },
+    { name: 'Polygon', chainId: 137, rpcUrl: 'https://polygon' },
+    { name: 'Mainnet', chainId: 10_000, rpcUrl: 'https://fork' },
+  ]
+
+  it('returns undefined for empty/undefined input', () => {
+    expect(resolveSelectedChainIds(undefined, networks)).toBeUndefined()
+    expect(resolveSelectedChainIds('', networks)).toBeUndefined()
+    expect(resolveSelectedChainIds('   ', networks)).toBeUndefined()
+  })
+
+  it('parses numeric IDs and removes duplicates', () => {
+    expect(resolveSelectedChainIds('1,1,42161', networks)).toEqual([1, 42161])
+  })
+
+  it('matches names case-insensitively and includes all with same name', () => {
+    expect(resolveSelectedChainIds('mainnet', networks)).toEqual([1, 10000])
+    expect(resolveSelectedChainIds('MAINNET,polygon', networks)).toEqual([1, 10000, 137])
+  })
+
+  it('preserves token order and then network order for name matches', () => {
+    expect(resolveSelectedChainIds('polygon,mainnet', networks)).toEqual([137, 1, 10000])
+  })
+
+  it('throws on unknown name', () => {
+    expect(() => resolveSelectedChainIds('unknown', networks)).toThrow(/Unknown network selector/)
+  })
+
+  it('resolveSingleChainId returns first match for name and first token for multi', () => {
+    expect(resolveSingleChainId('mainnet', networks)).toBe(1)
+    expect(resolveSingleChainId('137,1', networks)).toBe(137)
+  })
+})
+
+

package/src/lib/core/__tests__/engine.spec.ts

@@ -26,7 +26,9 @@ const TEST_BYTECODES = {
   // Mini contract with multiplication function
   MINI_CONTRACT: '0x608060405234801561000f575f5ffd5b5060043610610034575f3560e01c80636df5b97a14610038578063f8a8fd6d14610068575b5f5ffd5b610052600480360381019061004d91906100da565b610086565b60405161005f9190610127565b60405180910390f35b61007061009b565b60405161007d9190610127565b60405180910390f35b5f8183610093919061016d565b905092915050565b5f602a905090565b5f5ffd5b5f819050919050565b6100b9816100a7565b81146100c3575f5ffd5b50565b5f813590506100d4816100b0565b92915050565b5f5f604083850312156100f0576100ef6100a3565b5b5f6100fd858286016100c6565b925050602061010e858286016100c6565b9150509250929050565b610121816100a7565b82525050565b5f60208201905061013a5f830184610118565b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f610177826100a7565b9150610182836100a7565b9250828202610190816100a7565b915082820484148315176101a7576101a6610140565b5b509291505056fea264697066735822122071d40daa3d2beacd91f29d29ccf1c0b6f312e805f50b37166267c0a2a55e6e6164736f6c634300081c0033',
   // Minimal deployment bytecode
-  MINIMAL_DEPLOY: '0x608060405234801561000f575f5ffd5b50603e80601c5f395ff3fe60806040525f80fdfea264697066735822122071d40daa3d2beacd91f29d29ccf1c0b6f312e805f50b37166267c0a2a55e6e6164736f6c634300081c0033'
+  MINIMAL_DEPLOY: '0x608060405234801561000f575f5ffd5b50603e80601c5f395ff3fe60806040525f80fdfea264697066735822122071d40daa3d2beacd91f29d29ccf1c0b6f312e805f50b37166267c0a2a55e6e6164736f6c634300081c0033',
+  // Broken bytecode
+  BROKEN_BYTECODE: '0xff',
 } as const
 
 const TEST_VALUES = {
@@ -68,7 +70,7 @@ describe('ExecutionEngine', () => {
     
     // Create empty verification registry for tests
     const verificationRegistry = new VerificationPlatformRegistry()
-    engine = new ExecutionEngine(templates, undefined, verificationRegistry)
+    engine = new ExecutionEngine(templates, { verificationRegistry })
   })
 
   afterEach(async () => {
@@ -1480,6 +1482,35 @@ describe('ExecutionEngine', () => {
       expect(context.getOutput('nick-test.success')).toBe(true)
     })
 
+    it('should prevent failing Nick\'s method from being tested twice', async () => {
+      const action: Action = {
+        type: 'test-nicks-method',
+        name: 'nick-test-fail-twice',
+        arguments: {
+          bytecode: TEST_BYTECODES.BROKEN_BYTECODE, // Will break
+        }
+      }
+
+      await expect((engine as any).executeAction(action, context, new Map())).rejects.toThrow(new Error(`Nick's method test failed for action "nick-test-fail-twice"`))
+      await expect((engine as any).executeAction(action, context, new Map())).rejects.toThrow(new Error('Nick\'s method test already performed this run'))
+    })
+
+    it('should prevent passing Nick\'s method from being tested twice', async () => {
+      const action: Action = {
+        type: 'test-nicks-method',
+        name: 'nick-test-pass-twice',
+        arguments: {
+          bytecode: TEST_BYTECODES.SIMPLE_RETURN_42, // Will pass
+        }
+      }
+
+      await (engine as any).executeAction(action, context, new Map())
+      await (engine as any).executeAction(action, context, new Map())
+
+      // Should have success output
+      expect(context.getOutput('nick-test-pass-twice.success')).toBe(true)
+    })
+
     it('should handle missing optional parameters', async () => {
       const action: Action = {
         type: 'test-nicks-method',

package/src/lib/core/__tests__/json-integration.spec.ts

@@ -31,7 +31,7 @@ describe('JSON Integration Tests', () => {
 
     templates = new Map()
     const verificationRegistry = new VerificationPlatformRegistry()
-    engine = new ExecutionEngine(templates, undefined, verificationRegistry)
+    engine = new ExecutionEngine(templates, { verificationRegistry })
     resolver = new ValueResolver()
   })
 

package/src/lib/core/__tests__/multi-platform-verification.spec.ts

@@ -68,7 +68,7 @@ describe('Multi-Platform Verification Integration', () => {
     verificationRegistry.register(mockSourcifyPlatform)
 
     templates = new Map()
-    engine = new ExecutionEngine(templates, undefined, verificationRegistry)
+    engine = new ExecutionEngine(templates, { verificationRegistry })
 
     // Set up mock contract and build info
     const mockContract = {

package/src/lib/core/__tests__/static-action.spec.ts

@@ -27,7 +27,7 @@ describe('Static Action', () => {
 
     templates = new Map()
     const verificationRegistry = new VerificationPlatformRegistry()
-    engine = new ExecutionEngine(templates, undefined, verificationRegistry)
+    engine = new ExecutionEngine(templates, { verificationRegistry })
   })
 
   describe('static primitive action', () => {

package/src/lib/core/engine.ts

@@ -8,6 +8,13 @@ import { createDefaultVerificationRegistry, VerificationPlatformRegistry } from
 import { BuildInfo } from '../types/buildinfo'
 import { ethers } from 'ethers'
 
+export type EngineOptions = {
+  eventEmitter?: DeploymentEventEmitter
+  verificationRegistry?: VerificationPlatformRegistry
+  noPostCheckConditions?: boolean
+  allowMultipleNicksMethodTests?: boolean
+}
+
 /**
  * The ExecutionEngine is the core component that runs jobs and their actions.
  * It interprets the declarative YAML files, resolves values, interacts with the
@@ -19,13 +26,16 @@ export class ExecutionEngine {
   private readonly events: DeploymentEventEmitter
   private readonly verificationRegistry: VerificationPlatformRegistry
   private readonly noPostCheckConditions: boolean
+  private readonly allowMultipleNicksMethodTests: boolean
+  private nicksMethodTested: boolean = false
 
-  constructor(templates: Map<string, Template>, eventEmitter?: DeploymentEventEmitter, verificationRegistry?: VerificationPlatformRegistry, noPostCheckConditions?: boolean) {
+  constructor(templates: Map<string, Template>, options?: EngineOptions) {
     this.resolver = new ValueResolver()
     this.templates = templates
-    this.events = eventEmitter || deploymentEvents
-    this.verificationRegistry = verificationRegistry || createDefaultVerificationRegistry()
-    this.noPostCheckConditions = noPostCheckConditions ?? false
+    this.events = options?.eventEmitter || deploymentEvents
+    this.verificationRegistry = options?.verificationRegistry || createDefaultVerificationRegistry()
+    this.noPostCheckConditions = options?.noPostCheckConditions ?? false
+    this.allowMultipleNicksMethodTests = options?.allowMultipleNicksMethodTests ?? false
   }
 
   /**
@@ -781,6 +791,18 @@ export class ExecutionEngine {
         break
       }
       case 'test-nicks-method': {
+        if (this.nicksMethodTested && !this.allowMultipleNicksMethodTests) {
+          try {
+            if (context.getOutput(`${action.name}.success`) === true) {
+              // Return previous result
+              break
+            }
+          } catch (e) {
+            throw new Error(`Nick's method test already performed this run`)
+          }
+        }
+        this.nicksMethodTested = true
+
         // Default bytecode if none provided
         const defaultBytecode = '0x608060405234801561001057600080fd5b5061013d806100206000396000f3fe60806040526004361061001e5760003560e01c80639c4ae2d014610023575b600080fd5b6100cb6004803603604081101561003957600080fd5b81019060208101813564010000000081111561005457600080fd5b82018360208201111561006657600080fd5b8035906020019184600183028401116401000000008311171561008857600080fd5b91908080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525092955050913592506100cd915050565b005b60008183516020850134f56040805173ffffffffffffffffffffffffffffffffffffffff83168152905191925081900360200190a050505056fea264697066735822122033609f614f03931b92d88c309d698449bb77efcd517328d341fa4f923c5d8c7964736f6c63430007060033'
         

package/src/lib/deployer.ts

@@ -154,10 +154,16 @@ export class Deployer {
 
       // 4. Execute the plan.
       const verificationRegistry = createDefaultVerificationRegistry(this.options.etherscanApiKey)
-      const engine = new ExecutionEngine(this.loader.templates, this.events, verificationRegistry, this.noPostCheckConditions)
+      const engine = new ExecutionEngine(this.loader.templates, {
+        eventEmitter: this.events,
+        verificationRegistry,
+        noPostCheckConditions: this.noPostCheckConditions
+      })
       
       // Track if any jobs have failed
       let hasFailures = false
+      // Emit signer info once per network (chainId)
+      const signerInfoPrintedForChain = new Set<number>()
       
       for (const network of targetNetworks) {
         this.events.emitEvent({
@@ -168,7 +174,6 @@ export class Deployer {
             chainId: network.chainId
           }
         })
-        
         for (const jobName of jobsToRun) {
           const job = this.loader.jobs.get(jobName)!
           
@@ -204,6 +209,46 @@ export class Deployer {
               (context as unknown as { setJobConstants: (constants: unknown) => void }).setJobConstants(job.constants)
             }
             
+            // Emit signer info once per network using the first job's context
+            if (!signerInfoPrintedForChain.has(network.chainId)) {
+              try {
+                const getSignerFn = (context as unknown as {
+                  getResolvedSigner?: () => Promise<{ getAddress: () => Promise<string> }>
+                  signer?: { getAddress: () => Promise<string> }
+                }).getResolvedSigner
+                const signer = getSignerFn
+                  ? await getSignerFn.call(context)
+                  : (context as unknown as { signer?: { getAddress: () => Promise<string> } }).signer
+                if (signer && typeof signer.getAddress === 'function') {
+                  const address = await signer.getAddress()
+                  // provider may not exist on mocked contexts; guard for it
+                  const provider = (context as unknown as {
+                    provider?: { getBalance: (addr: string) => Promise<bigint | number | { toString: () => string }> }
+                  }).provider
+                  if (provider && typeof provider.getBalance === 'function') {
+                    const balanceBn = await provider.getBalance(address)
+                    const balanceWei = balanceBn.toString()
+                    const balanceEth = (Number(balanceBn) / 1e18).toString()
+                    this.events.emitEvent({
+                      type: 'network_signer_info',
+                      level: 'info',
+                      data: {
+                        networkName: network.name,
+                        chainId: network.chainId,
+                        address,
+                        balanceWei,
+                        balance: balanceEth
+                      }
+                    })
+                  }
+                }
+              } catch {
+                // ignore non-fatal signer info errors
+              } finally {
+                signerInfoPrintedForChain.add(network.chainId)
+              }
+            }
+
             // Populate context with outputs from previously executed dependent jobs
             this.populateContextWithDependentJobOutputs(job, context, network)
             
@@ -275,12 +320,32 @@ export class Deployer {
       // Check if any jobs failed and exit with error if so
       if (hasFailures) {
         const error = new Error('One or more jobs failed during execution')
+
+        // Build a flat list of failed jobs with network context and error messages
+        const failedJobs: Array<{ jobName: string; networkName: string; chainId: number; error: string }> = []
+        for (const [, result] of this.results) {
+          const job = result.job
+          for (const [chainId, netResult] of result.outputs) {
+            if (netResult.status === 'error') {
+              // Resolve network name from configured networks (fallback to chainId if missing)
+              const network = this.options.networks.find(n => n.chainId === chainId)
+              failedJobs.push({
+                jobName: job.name,
+                networkName: network?.name || `chain-${chainId}`,
+                chainId,
+                error: String(netResult.data)
+              })
+            }
+          }
+        }
+
         this.events.emitEvent({
           type: 'deployment_failed',
           level: 'error',
           data: {
             error: error.message,
-            stack: error.stack
+            stack: error.stack,
+            failedJobs
           }
         })
         throw error

package/src/lib/events/cli-adapter.ts

@@ -48,7 +48,7 @@ export class CLIEventAdapter {
     const level0Events = new Set([
       'deployment_started', 'deployment_completed', 'deployment_failed',
       'job_started', 'job_completed', 'job_skipped', 'job_execution_failed',
-      'network_started',
+      'network_started', 'network_signer_info',
       'duplicate_artifact_warning', 'missing_network_config_warning',
       'unhandled_rejection', 'uncaught_exception', 'cli_error',
       'verification_failed'
@@ -115,6 +115,11 @@ export class CLIEventAdapter {
         console.log(chalk.cyan.bold(`\nNetwork: ${event.data.networkName} (ChainID: ${event.data.chainId})`))
         break
 
+      case 'network_signer_info':
+        console.log(chalk.gray(`        Sender: ${event.data.address}`))
+        console.log(chalk.gray(`        Balance: ${event.data.balance} ETH (${event.data.balanceWei} wei)`))
+        break
+
       case 'job_started':
         console.log(chalk.cyan.bold(`\n🚀 Starting job: ${event.data.jobName} (v${event.data.jobVersion})`))
         break
@@ -197,10 +202,21 @@ export class CLIEventAdapter {
 
       case 'deployment_failed':
         console.error(chalk.red.bold('\n💥 DEPLOYMENT FAILED!'))
-        if (event.data.stack) {
-          console.error(chalk.red(event.data.stack))
-        } else {
-          console.error(chalk.red(event.data.error))
+        // Show concise failed jobs table if present
+        const failedJobs = (event as any).data?.failedJobs as Array<{ jobName: string; networkName: string; chainId: number; error: string }> | undefined
+        if (Array.isArray(failedJobs) && failedJobs.length > 0) {
+          console.error(chalk.red('   ✗ Failed jobs:'))
+          for (const f of failedJobs) {
+            const where = `${f.networkName} (ChainID: ${f.chainId})`
+            console.error(chalk.red(`     - ${f.jobName} on ${where}`))
+            console.error(chalk.red(`       Error: ${f.error}`))
+          }
+        }
+        // Always print the top-level error and stack last
+        if ((event as any).data?.stack) {
+          console.error(chalk.red((event as any).data.stack))
+        } else if ((event as any).data?.error) {
+          console.error(chalk.red((event as any).data.error))
         }
         break
 

package/src/lib/events/types.ts

@@ -29,6 +29,12 @@ export interface DeploymentFailedEvent extends BaseEvent {
   data: {
     error: string
     stack?: string
+    failedJobs?: Array<{
+      jobName: string
+      networkName: string
+      chainId: number
+      error: string
+    }>
   }
 }
 
@@ -312,6 +318,22 @@ export interface NetworkStartedEvent extends BaseEvent {
   }
 }
 
+/**
+ * Emitted right after a network run starts to inform which address will be used
+ * to send transactions and its current balance.
+ */
+export interface NetworkSignerInfoEvent extends BaseEvent {
+  type: 'network_signer_info'
+  level: 'info'
+  data: {
+    networkName: string
+    chainId: number
+    address: string
+    balanceWei: string
+    balance: string // formatted in ETH
+  }
+}
+
 // Process error events
 export interface UnhandledRejectionEvent extends BaseEvent {
   type: 'unhandled_rejection'
@@ -457,6 +479,7 @@ export type DeploymentEvent =
   | ContextDisposalWarningEvent
   | DeprecatedJobsSkippedEvent
   | NetworkStartedEvent
+  | NetworkSignerInfoEvent
   | UnhandledRejectionEvent
   | UncaughtExceptionEvent
   | CLIErrorEvent

package/src/lib/network-loader.ts

@@ -37,7 +37,8 @@ function resolveRpcUrlTokens(rpcUrl: string): string {
     }
     const value = process.env[varName]
     if (typeof value === 'undefined') {
-      throw new Error(`Environment variable ${varName} is not set but is required for rpcUrl token replacement`)
+      // Default to empty string if missing
+      return ''
     }
     return value
   })