@0xsequence/catapult 1.3.3 → 1.3.4

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 = {

package/src/lib/core/engine.ts

@@ -13,6 +13,7 @@ export type EngineOptions = {
   verificationRegistry?: VerificationPlatformRegistry
   noPostCheckConditions?: boolean
   allowMultipleNicksMethodTests?: boolean
+  ignoreVerifyErrors?: boolean
 }
 
 /**
@@ -27,7 +28,17 @@ export class ExecutionEngine {
   private readonly verificationRegistry: VerificationPlatformRegistry
   private readonly noPostCheckConditions: boolean
   private readonly allowMultipleNicksMethodTests: boolean
+  private readonly ignoreVerifyErrors: boolean
   private nicksMethodTested: boolean = false
+  private verificationWarnings: Array<{
+    actionName: string
+    address: string
+    contractName: string
+    platform: string
+    error: string
+    jobName?: string
+    networkName?: string
+  }> = []
 
   constructor(templates: Map<string, Template>, options?: EngineOptions) {
     this.resolver = new ValueResolver()
@@ -36,6 +47,7 @@ export class ExecutionEngine {
     this.verificationRegistry = options?.verificationRegistry || createDefaultVerificationRegistry()
     this.noPostCheckConditions = options?.noPostCheckConditions ?? false
     this.allowMultipleNicksMethodTests = options?.allowMultipleNicksMethodTests ?? false
+    this.ignoreVerifyErrors = options?.ignoreVerifyErrors ?? false
   }
 
   /**
@@ -631,6 +643,20 @@ export class ExecutionEngine {
               )
               anySuccess = true
             } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : String(error)
+              
+              // If ignoreVerifyErrors is enabled, add to warnings and continue
+              if (this.ignoreVerifyErrors) {
+                this.verificationWarnings.push({
+                  actionName: actionName,
+                  address,
+                  contractName,
+                  platform: platform.name,
+                  error: errorMessage,
+                  networkName: network.name
+                })
+              }
+              
               // Log the error but continue with other platforms
               this.events.emitEvent({
                 type: 'verification_failed',
@@ -640,14 +666,26 @@ export class ExecutionEngine {
                   address,
                   contractName,
                   platform: platform.name,
-                  error: error instanceof Error ? error.message : String(error)
+                  error: errorMessage
                 }
               })
             }
           }
 
           if (!anySuccess) {
-            throw new Error(`Verification failed on all configured platforms for network ${network.name}`)
+            if (this.ignoreVerifyErrors) {
+              // Don't throw error if ignoreVerifyErrors is enabled - warnings already collected
+              this.events.emitEvent({
+                type: 'verification_skipped',
+                level: 'warn',
+                data: {
+                  actionName: actionName,
+                  reason: `Verification failed on all configured platforms for network ${network.name}, but continuing due to --ignore-verify-errors`
+                }
+              })
+            } else {
+              throw new Error(`Verification failed on all configured platforms for network ${network.name}`)
+            }
           }
         } else {
           // Handle specific platform(s) verification
@@ -673,6 +711,20 @@ export class ExecutionEngine {
               )
               anySuccess = true
             } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : String(error)
+              
+              // If ignoreVerifyErrors is enabled, add to warnings
+              if (this.ignoreVerifyErrors) {
+                this.verificationWarnings.push({
+                  actionName: actionName,
+                  address,
+                  contractName,
+                  platform: platform.name,
+                  error: errorMessage,
+                  networkName: network.name
+                })
+              }
+              
               // Log the error but continue with other platforms if multiple specified
               this.events.emitEvent({
                 type: 'verification_failed',
@@ -682,19 +734,31 @@ export class ExecutionEngine {
                   address,
                   contractName,
                   platform: platform.name,
-                  error: error instanceof Error ? error.message : String(error)
+                  error: errorMessage
                 }
               })
               
-              // If only one platform specified, re-throw the error
-              if (platformsToTry.length === 1) {
+              // If only one platform specified, re-throw the error unless ignoreVerifyErrors is enabled
+              if (platformsToTry.length === 1 && !this.ignoreVerifyErrors) {
                 throw error
               }
             }
           }
 
           if (!anySuccess && platformsToTry.length > 1) {
-            throw new Error(`Verification failed on all specified platforms: ${platformsToTry.join(', ')}`)
+            if (this.ignoreVerifyErrors) {
+              // Don't throw error if ignoreVerifyErrors is enabled - warnings already collected
+              this.events.emitEvent({
+                type: 'verification_skipped',
+                level: 'warn',
+                data: {
+                  actionName: actionName,
+                  reason: `Verification failed on all specified platforms: ${platformsToTry.join(', ')}, but continuing due to --ignore-verify-errors`
+                }
+              })
+            } else {
+              throw new Error(`Verification failed on all specified platforms: ${platformsToTry.join(', ')}`)
+            }
           }
         }
 
@@ -1635,4 +1699,26 @@ export class ExecutionEngine {
 
     return sorted
   }
+
+  /**
+   * Get all verification warnings that were collected when ignoreVerifyErrors is enabled
+   */
+  public getVerificationWarnings(): Array<{
+    actionName: string
+    address: string
+    contractName: string
+    platform: string
+    error: string
+    jobName?: string
+    networkName?: string
+  }> {
+    return [...this.verificationWarnings]
+  }
+
+  /**
+   * Clear verification warnings (useful for testing)
+   */
+  public clearVerificationWarnings(): void {
+    this.verificationWarnings = []
+  }
 }