@0xsequence/catapult 1.3.3 → 1.3.5

package/dist/lib/utils/assertion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion.js","sourceRoot":"","sources":["../../../src/lib/utils/assertion.ts"],"names":[],"mappings":";;AAEA,8BAEC;AAED,kCAEC;AAED,wCAaC;AAvBD,mCAAgC;AAEhC,SAAgB,SAAS,CAAC,KAAc;IACtC,OAAO,eAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;AAChC,CAAC;AAED,SAAgB,WAAW,CAAC,KAAc;IACxC,OAAO,eAAM,CAAC,WAAW,CAAC,KAAK,CAAC,CAAA;AAClC,CAAC;AAED,SAAgB,cAAc,CAAC,KAAc;IAC3C,IAAI,CAAC;QACH,QAAQ,OAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YACtB,KAAK,QAAQ,CAAC;YACd,KAAK,QAAQ,CAAC;YACd,KAAK,QAAQ;gBACX,eAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;gBACtB,OAAO,IAAI,CAAA;QACf,CAAC;IACH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;IAEjB,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/catapult",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "Ethereum contract deployment CLI tool",
   "main": "dist/index.js",
   "bin": {

package/src/commands/run.ts

@@ -21,6 +21,7 @@ interface RunOptions {
   noPostCheckConditions: boolean
   flatOutput: boolean
   summary: boolean
+  ignoreVerifyErrors: boolean
 }
  
 export function makeRunCommand(): Command {
@@ -36,6 +37,7 @@ export function makeRunCommand(): Command {
     .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)
@@ -113,7 +115,8 @@ export function makeRunCommand(): Command {
           loadStdTemplates: options.std !== false
         },
         flatOutput: options.flatOutput === true,
-        runDeprecated: (options as { runDeprecated?: boolean }).runDeprecated === true
+        runDeprecated: (options as { runDeprecated?: boolean }).runDeprecated === true,
+        ignoreVerifyErrors: options.ignoreVerifyErrors === true
       } as DeployerOptions
 
       const deployer = new Deployer(deployerOptions)

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

@@ -117,7 +117,8 @@ describe('Deployer', () => {
     } as any
 
     mockEngine = {
-      executeJob: jest.fn().mockResolvedValue(undefined)
+      executeJob: jest.fn().mockResolvedValue(undefined),
+      getVerificationWarnings: jest.fn().mockReturnValue([])
     } as any
 
     mockContext = {
@@ -1199,4 +1200,110 @@ describe('Deployer', () => {
       expect(mockEngine.executeJob).toHaveBeenCalledTimes(2)
     })
   })
+
+  describe('ignore verify errors feature', () => {
+    it('should pass ignoreVerifyErrors option to ExecutionEngine', async () => {
+      const optionsWithIgnoreVerifyErrors = {
+        ...deployerOptions,
+        ignoreVerifyErrors: true
+      }
+
+      const deployer = new Deployer(optionsWithIgnoreVerifyErrors)
+      await deployer.run()
+
+      // Verify that ExecutionEngine was created with ignoreVerifyErrors option
+      expect(MockExecutionEngine).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({
+          ignoreVerifyErrors: true
+        })
+      )
+    })
+
+    it('should emit verification warnings report when ignoreVerifyErrors is enabled', async () => {
+      const mockWarnings = [
+        {
+          actionName: 'verify-test',
+          address: '0x1234567890123456789012345678901234567890',
+          contractName: 'TestContract',
+          platform: 'etherscan_v2',
+          error: 'Failed to verify contract',
+          networkName: 'mainnet'
+        }
+      ]
+
+      // Mock engine to return warnings
+      mockEngine.getVerificationWarnings = jest.fn().mockReturnValue(mockWarnings)
+
+      const optionsWithIgnoreVerifyErrors = {
+        ...deployerOptions,
+        ignoreVerifyErrors: true
+      }
+
+      const deployer = new Deployer(optionsWithIgnoreVerifyErrors)
+      
+      // Mock event emitter to track events
+      const mockEmitEvent = jest.fn()
+      ;(deployer as any).events = { emitEvent: mockEmitEvent }
+
+      await deployer.run()
+
+      // Verify that verification warnings report was emitted
+      expect(mockEmitEvent).toHaveBeenCalledWith({
+        type: 'verification_warnings_report',
+        level: 'warn',
+        data: {
+          totalWarnings: 1,
+          warnings: mockWarnings
+        }
+      })
+    })
+
+    it('should not emit verification warnings report when ignoreVerifyErrors is disabled', async () => {
+      const optionsWithoutIgnoreVerifyErrors = {
+        ...deployerOptions,
+        ignoreVerifyErrors: false
+      }
+
+      const deployer = new Deployer(optionsWithoutIgnoreVerifyErrors)
+      
+      // Mock event emitter to track events
+      const mockEmitEvent = jest.fn()
+      ;(deployer as any).events = { emitEvent: mockEmitEvent }
+
+      await deployer.run()
+
+      // Verify that verification warnings report was NOT emitted
+      expect(mockEmitEvent).not.toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'verification_warnings_report'
+        })
+      )
+    })
+
+    it('should not emit verification warnings report when there are no warnings', async () => {
+      // Mock engine to return no warnings
+      mockEngine.getVerificationWarnings = jest.fn().mockReturnValue([])
+
+      const optionsWithIgnoreVerifyErrors = {
+        ...deployerOptions,
+        ignoreVerifyErrors: true
+      }
+
+      const deployer = new Deployer(optionsWithIgnoreVerifyErrors)
+      
+      // Mock event emitter to track events
+      const mockEmitEvent = jest.fn()
+      ;(deployer as any).events = { emitEvent: mockEmitEvent }
+
+      await deployer.run()
+
+      // Verify that verification warnings report was NOT emitted when no warnings
+      expect(mockEmitEvent).not.toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'verification_warnings_report'
+        })
+      )
+    })
+  })
 }) 

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

@@ -1542,4 +1542,325 @@ describe('ExecutionEngine', () => {
       expect(context.getOutput('nick-test-default-bytecode.success')).toBe(true)
     })
   })
+
+  describe('ignore verify errors feature', () => {
+    beforeEach(() => {
+      // Mock fs.readFile to return valid build info
+      jest.doMock('fs/promises', () => ({
+        readFile: jest.fn().mockResolvedValue(JSON.stringify({
+          _format: 'hh-sol-build-info-1',
+          id: 'test-id',
+          solcVersion: '0.8.0',
+          input: {
+            language: 'Solidity',
+            sources: {
+              'TestContract.sol': {
+                content: 'contract TestContract { }'
+              }
+            },
+            settings: {
+              optimizer: { enabled: true, runs: 200 },
+              outputSelection: { '*': { '*': ['*'] } }
+            }
+          },
+          output: {
+            contracts: {},
+            sources: {}
+          }
+        }))
+      }))
+
+      // Create a mock verification registry with a failing platform
+      const mockVerificationRegistry = new VerificationPlatformRegistry()
+      const mockPlatform = {
+        name: 'mock-platform',
+        supportsNetwork: jest.fn().mockReturnValue(true),
+        isConfigured: jest.fn().mockReturnValue(true),
+        getConfigurationRequirements: jest.fn().mockReturnValue(''),
+        isContractAlreadyVerified: jest.fn().mockResolvedValue(false),
+        verifyContract: jest.fn().mockRejectedValue(new Error('Verification failed'))
+      }
+      mockVerificationRegistry.register(mockPlatform)
+      
+      engine = new ExecutionEngine(templates, { 
+        verificationRegistry: mockVerificationRegistry,
+        ignoreVerifyErrors: true
+      })
+    })
+
+    it('should collect verification warnings when ignoreVerifyErrors is enabled', async () => {
+      const mockContract = {
+        sourceName: 'TestContract.sol',
+        contractName: 'TestContract',
+        compiler: { version: '0.8.0' },
+        buildInfoId: 'test-build-id',
+        source: 'contract TestContract { }',
+        creationCode: '0x608060405234801561000f575f5ffd5b50602a5f526020601ff3',
+        abi: [],
+        _sources: new Set(['TestContract.sol', '/path/to/build-info/test.json'])
+      }
+      
+      context.contractRepository.addForTesting({
+        contractName: mockContract.contractName,
+        abi: mockContract.abi,
+        bytecode: mockContract.creationCode,
+        sourceName: mockContract.sourceName,
+        source: mockContract.source,
+        compiler: mockContract.compiler,
+        buildInfoId: mockContract.buildInfoId,
+        _path: '/test/path',
+        _hash: 'test-hash'
+      })
+      
+      const action: Action = {
+        type: 'verify-contract',
+        name: 'test-verify',
+        arguments: {
+          address: TEST_ADDRESSES.RECIPIENT_1,
+          contract: '{{Contract(TestContract)}}',
+          platform: 'mock-platform'
+        }
+      }
+
+      // Should not throw even though verification fails
+      await expect((engine as any).executePrimitive(action, context, new Map()))
+        .resolves.not.toThrow()
+
+      // Should have collected the warning
+      const warnings = engine.getVerificationWarnings()
+      expect(warnings).toHaveLength(1)
+      expect(warnings[0]).toMatchObject({
+        actionName: 'test-verify',
+        address: TEST_ADDRESSES.RECIPIENT_1,
+        contractName: 'TestContract.sol:TestContract',
+        platform: 'mock-platform',
+        error: 'Action "test-verify": No build-info file found in contract sources'
+      })
+    })
+
+    it('should throw verification errors when ignoreVerifyErrors is disabled', async () => {
+      // Create engine with ignoreVerifyErrors disabled
+      const mockVerificationRegistry = new VerificationPlatformRegistry()
+      const mockPlatform = {
+        name: 'mock-platform',
+        supportsNetwork: jest.fn().mockReturnValue(true),
+        isConfigured: jest.fn().mockReturnValue(true),
+        getConfigurationRequirements: jest.fn().mockReturnValue(''),
+        isContractAlreadyVerified: jest.fn().mockResolvedValue(false),
+        verifyContract: jest.fn().mockRejectedValue(new Error('Verification failed'))
+      }
+      mockVerificationRegistry.register(mockPlatform)
+      
+      const engineWithoutIgnore = new ExecutionEngine(templates, { 
+        verificationRegistry: mockVerificationRegistry,
+        ignoreVerifyErrors: false
+      })
+
+      const mockContract = {
+        sourceName: 'TestContract.sol',
+        contractName: 'TestContract',
+        compiler: { version: '0.8.0' },
+        buildInfoId: 'test-build-id',
+        source: 'contract TestContract { }',
+        creationCode: '0x608060405234801561000f575f5ffd5b50602a5f526020601ff3',
+        abi: [],
+        _sources: new Set(['TestContract.sol', '/path/to/build-info/test.json'])
+      }
+      
+      context.contractRepository.addForTesting({
+        contractName: mockContract.contractName,
+        abi: mockContract.abi,
+        bytecode: mockContract.creationCode,
+        sourceName: mockContract.sourceName,
+        source: mockContract.source,
+        compiler: mockContract.compiler,
+        buildInfoId: mockContract.buildInfoId,
+        _path: '/test/path',
+        _hash: 'test-hash'
+      })
+      
+      const action: Action = {
+        type: 'verify-contract',
+        name: 'test-verify',
+        arguments: {
+          address: TEST_ADDRESSES.RECIPIENT_1,
+          contract: '{{Contract(TestContract)}}',
+          platform: 'mock-platform'
+        }
+      }
+
+      // Should throw when ignoreVerifyErrors is disabled
+      await expect((engineWithoutIgnore as any).executePrimitive(action, context, new Map()))
+        .rejects.toThrow('Action "test-verify": No build-info file found in contract sources')
+    })
+
+    it('should handle multiple platform verification failures with ignoreVerifyErrors', async () => {
+      const mockVerificationRegistry = new VerificationPlatformRegistry()
+      
+      // Create multiple failing platforms
+      const platforms = ['platform1', 'platform2', 'platform3']
+      platforms.forEach(name => {
+        const mockPlatform = {
+          name,
+          supportsNetwork: jest.fn().mockReturnValue(true),
+          isConfigured: jest.fn().mockReturnValue(true),
+          getConfigurationRequirements: jest.fn().mockReturnValue(''),
+          isContractAlreadyVerified: jest.fn().mockResolvedValue(false),
+          verifyContract: jest.fn().mockRejectedValue(new Error(`${name} verification failed`))
+        }
+        mockVerificationRegistry.register(mockPlatform)
+      })
+      
+      engine = new ExecutionEngine(templates, { 
+        verificationRegistry: mockVerificationRegistry,
+        ignoreVerifyErrors: true
+      })
+
+      const mockContract = {
+        sourceName: 'TestContract.sol',
+        contractName: 'TestContract',
+        compiler: { version: '0.8.0' },
+        buildInfoId: 'test-build-id',
+        source: 'contract TestContract { }',
+        creationCode: '0x608060405234801561000f575f5ffd5b50602a5f526020601ff3',
+        abi: [],
+        _sources: new Set(['TestContract.sol', '/path/to/build-info/test.json'])
+      }
+      
+      context.contractRepository.addForTesting({
+        contractName: mockContract.contractName,
+        abi: mockContract.abi,
+        bytecode: mockContract.creationCode,
+        sourceName: mockContract.sourceName,
+        source: mockContract.source,
+        compiler: mockContract.compiler,
+        buildInfoId: mockContract.buildInfoId,
+        _path: '/test/path',
+        _hash: 'test-hash'
+      })
+      
+      const action: Action = {
+        type: 'verify-contract',
+        name: 'test-verify',
+        arguments: {
+          address: TEST_ADDRESSES.RECIPIENT_1,
+          contract: '{{Contract(TestContract)}}',
+          platform: platforms
+        }
+      }
+
+      // Should not throw even with multiple platform failures
+      await expect((engine as any).executePrimitive(action, context, new Map()))
+        .resolves.not.toThrow()
+
+      // Should have collected warnings for all platforms
+      const warnings = engine.getVerificationWarnings()
+      expect(warnings).toHaveLength(3)
+      
+      platforms.forEach((platform, index) => {
+        expect(warnings[index]).toMatchObject({
+          actionName: 'test-verify',
+          platform,
+          error: 'Action "test-verify": No build-info file found in contract sources'
+        })
+      })
+    })
+
+    it('should provide methods to get and clear verification warnings', () => {
+      // Initially empty
+      expect(engine.getVerificationWarnings()).toEqual([])
+
+      // Manually add a warning (simulating what happens during verification)
+      ;(engine as any).verificationWarnings.push({
+        actionName: 'test',
+        address: '0x123',
+        contractName: 'Test',
+        platform: 'test-platform',
+        error: 'test error'
+      })
+
+      // Should return the warning
+      const warnings = engine.getVerificationWarnings()
+      expect(warnings).toHaveLength(1)
+      expect(warnings[0]).toMatchObject({
+        actionName: 'test',
+        error: 'test error'
+      })
+
+      // Clear warnings
+      engine.clearVerificationWarnings()
+      expect(engine.getVerificationWarnings()).toEqual([])
+    })
+
+    it('should emit verification_skipped events when all platforms fail and ignoreVerifyErrors is enabled', async () => {
+      const mockVerificationRegistry = new VerificationPlatformRegistry()
+      const mockPlatform = {
+        name: 'mock-platform',
+        supportsNetwork: jest.fn().mockReturnValue(true),
+        isConfigured: jest.fn().mockReturnValue(true),
+        getConfigurationRequirements: jest.fn().mockReturnValue(''),
+        isContractAlreadyVerified: jest.fn().mockResolvedValue(false),
+        verifyContract: jest.fn().mockRejectedValue(new Error('Verification failed'))
+      }
+      mockVerificationRegistry.register(mockPlatform)
+      mockVerificationRegistry.getConfiguredPlatforms = jest.fn().mockReturnValue([mockPlatform])
+      
+      const mockEventEmitter = {
+        emitEvent: jest.fn()
+      }
+      
+      engine = new ExecutionEngine(templates, { 
+        verificationRegistry: mockVerificationRegistry,
+        ignoreVerifyErrors: true,
+        eventEmitter: mockEventEmitter as any
+      })
+
+      const mockContract = {
+        sourceName: 'TestContract.sol',
+        contractName: 'TestContract',
+        compiler: { version: '0.8.0' },
+        buildInfoId: 'test-build-id',
+        source: 'contract TestContract { }',
+        creationCode: '0x608060405234801561000f575f5ffd5b50602a5f526020601ff3',
+        abi: [],
+        _sources: new Set(['TestContract.sol', '/path/to/build-info/test.json'])
+      }
+      
+      context.contractRepository.addForTesting({
+        contractName: mockContract.contractName,
+        abi: mockContract.abi,
+        bytecode: mockContract.creationCode,
+        sourceName: mockContract.sourceName,
+        source: mockContract.source,
+        compiler: mockContract.compiler,
+        buildInfoId: mockContract.buildInfoId,
+        _path: '/test/path',
+        _hash: 'test-hash'
+      })
+      
+      const action: Action = {
+        type: 'verify-contract',
+        name: 'test-verify',
+        arguments: {
+          address: TEST_ADDRESSES.RECIPIENT_1,
+          contract: '{{Contract(TestContract)}}',
+          platform: 'all'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+
+      // Should emit verification_skipped event
+      expect(mockEventEmitter.emitEvent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'verification_skipped',
+          level: 'warn',
+          data: expect.objectContaining({
+            actionName: 'test-verify',
+            reason: expect.stringContaining('continuing due to --ignore-verify-errors')
+          })
+        })
+      )
+    })
+  })
 })