@0xsequence/catapult 1.3.2 → 1.3.4

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')
+          })
+        })
+      )
+    })
+  })
 }) 

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

@@ -1,7 +1,7 @@
 import { ethers } from 'ethers'
 import { ValueResolver } from '../resolver'
 import { ExecutionContext } from '../context'
-import { BasicArithmeticValue, Network, ReadBalanceValue, ComputeCreate2Value, ConstructorEncodeValue, AbiEncodeValue, AbiPackValue, CallValue, ContractExistsValue } from '../../types'
+import { BasicArithmeticValue, Network, ReadBalanceValue, ComputeCreate2Value, ConstructorEncodeValue, AbiEncodeValue, AbiPackValue, CallValue, ContractExistsValue, ComputeCreateValue } from '../../types'
 import { ContractRepository } from '../../contracts/repository'
 
 describe('ValueResolver', () => {
@@ -494,6 +494,155 @@ describe('ValueResolver', () => {
     })
   })
 
+  describe('compute-create', () => {
+    it('should compute CREATE address with hardcoded test case 1', async () => {
+      const value: ComputeCreateValue = {
+        type: 'compute-create',
+        arguments: {
+          deployerAddress: '0x0000000000000000000000000000000000000000',
+          nonce: '0',
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe('0xBd770416a3345F91E4B34576cb804a576fa48EB1')
+    })
+
+    it('should compute CREATE address with hardcoded test case 2', async () => {
+      const value: ComputeCreateValue = {
+        type: 'compute-create',
+        arguments: {
+          deployerAddress: '0xC6064FfBaDB0687Da29721C8EC02ACa71e735a3e',
+          nonce: '1',
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe('0x6d2E686984620c01Af3cd125F9E1A2E23a972FFc')
+    })
+
+    it('should compute CREATE address with hardcoded test case 3', async () => {
+      const value: ComputeCreateValue = {
+        type: 'compute-create',
+        arguments: {
+          deployerAddress: '0xC6064FfBaDB0687Da29721C8EC02ACa71e735a3e',
+          nonce: '2',
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe('0xBA6CfaFc33eD8229D2Af9a5a7BC22e8834cE0873')
+    })
+
+    it('should compute CREATE address with hardcoded test case ERC-2470', async () => {
+      const value: ComputeCreateValue = {
+        type: 'compute-create',
+        arguments: {
+          deployerAddress: '0xBb6e024b9cFFACB947A71991E386681B1Cd1477D',
+          nonce: '0',
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe('0xce0042B868300000d44A59004Da54A005ffdcf9f')
+    })
+
+    it('should compute CREATE address with hardcoded test case Universal Deployer', async () => {
+      const value: ComputeCreateValue = {
+        type: 'compute-create',
+        arguments: {
+          deployerAddress: '0x9c5a87452d4FAC0cbd53BDCA580b20A45526B3AB',
+          nonce: '0',
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe('0x1B926fBB24A9F78DCDd3272f2d86F5D0660E59c0')
+    })
+
+    it('should resolve values from context before computing CREATE address', async () => {
+      context.setOutput('myDeployer', '0x0000000000000000000000000000000000000000')
+      context.setOutput('myNonce', '0')
+      
+      const value: ComputeCreateValue = {
+        type: 'compute-create',
+        arguments: {
+          deployerAddress: '{{myDeployer}}',
+          nonce: '{{myNonce}}',
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe('0xBd770416a3345F91E4B34576cb804a576fa48EB1')
+    })
+
+    it('should throw error for invalid deployer address', async () => {
+      const value: ComputeCreateValue = {
+        type: 'compute-create',
+        arguments: {
+          deployerAddress: 'invalid-address',
+          nonce: '0',
+        },
+      }
+      
+      await expect(resolver.resolve(value, context)).rejects.toThrow('Invalid deployer address: invalid-address')
+    })
+
+    it('should throw error for invalid nonce', async () => {
+      const value: ComputeCreateValue = {
+        type: 'compute-create',
+        arguments: {
+          deployerAddress: '0x0000000000000000000000000000000000000000',
+          nonce: 'invalid-nonce',
+        },
+      }
+      
+      await expect(resolver.resolve(value, context)).rejects.toThrow('Invalid nonce: invalid-nonce')
+    })
+
+    it('should throw error for null deployer address', async () => {
+      const value: ComputeCreateValue = {
+        type: 'compute-create',
+        arguments: {
+          deployerAddress: null as any,
+          nonce: '0',
+        },
+      }
+      
+      await expect(resolver.resolve(value, context)).rejects.toThrow('Invalid deployer address: null')
+    })
+
+    it('should throw error for undefined nonce', async () => {
+      const value: ComputeCreateValue = {
+        type: 'compute-create',
+        arguments: {
+          deployerAddress: '0x0000000000000000000000000000000000000000',
+          nonce: undefined as any,
+        },
+      }
+      
+      await expect(resolver.resolve(value, context)).rejects.toThrow('Invalid nonce: undefined')
+    })
+
+    it('should handle checksummed addresses', async () => {
+      const value: ComputeCreateValue = {
+        type: 'compute-create',
+        arguments: {
+          deployerAddress: '0xdEADBEeF00000000000000000000000000000000',
+          nonce: '0',
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe('0xf2048C36a5536FeA3Bc71d49ed59f2c65C546EEA')
+    })
+
+    it('should handle number nonce', async () => {
+      const value: ComputeCreateValue = {
+        type: 'compute-create',
+        arguments: {
+          deployerAddress: '0x0000000000000000000000000000000000000000',
+          nonce: 69420,
+        },
+      }
+      const result = await resolver.resolve(value, context)
+      expect(result).toBe('0x7Bd7F19787DA009bD75b849c92Db10CE11916487')
+    })
+  })
+
   describe('constructor-encode', () => {
     it('should encode creation code with no constructor arguments', async () => {
       const value = {