@0xsequence/catapult 1.3.3 → 1.3.5

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', () => {
@@ -15,7 +15,14 @@ describe('ValueResolver', () => {
     mockRegistry = new ContractRepository()
     // Allow configuring RPC URL via environment variable for CI
     const rpcUrl = process.env.RPC_URL || 'http://127.0.0.1:8545'
-    mockNetwork = { name: 'testnet', chainId: 999, rpcUrl }
+    mockNetwork = {
+      name: 'testnet',
+      chainId: 999,
+      rpcUrl,
+      supports: ["sourcify", "etherscan_v2"],
+      gasLimit: 10000000,
+      evmVersion: 'cancun',
+    }
     // A dummy private key is fine as these tests don't send transactions
     const mockPrivateKey = '0x0000000000000000000000000000000000000000000000000000000000000001'
     context = new ExecutionContext(mockNetwork, mockPrivateKey, mockRegistry)
@@ -494,6 +501,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 = {
@@ -1057,7 +1213,7 @@ describe('ValueResolver', () => {
     })
   })
 
-  describe('artifact function expressions', () => {
+  describe('contract artifact function expressions', () => {
     beforeEach(() => {
       // Add test artifacts to the registry
       const testArtifact1 = {
@@ -1341,6 +1497,78 @@ describe('ValueResolver', () => {
     })
   })
 
+  describe('network function expressions', () => {
+    describe('Network().property', () => {
+      it('should return name for valid network', async () => {
+        const result = await resolver.resolve('{{Network().name}}', context)
+        expect(result).toBe(mockNetwork.name)
+      })
+
+      it('should return handle whitespace after expression', async () => {
+        const result = await resolver.resolve('{{Network().name }}', context)
+        expect(result).toBe(mockNetwork.name)
+      })
+
+      it('should return handle whitespace before expression', async () => {
+        const result = await resolver.resolve('{{ Network().name}}', context)
+        expect(result).toBe(mockNetwork.name)
+      })
+
+      it('should return handle whitespace around expression', async () => {
+        const result = await resolver.resolve('{{ Network().name }}', context)
+        expect(result).toBe(mockNetwork.name)
+      })
+  
+      it('should return chainId for valid network', async () => {
+        const result = await resolver.resolve('{{Network().chainId}}', context)
+        expect(result).toBe(mockNetwork.chainId)
+      })
+  
+      it('should return rpcUrl for valid network', async () => {
+        const result = await resolver.resolve('{{Network().rpcUrl}}', context)
+        expect(result).toBe(mockNetwork.rpcUrl)
+      })
+  
+      it('should return supports for valid network', async () => {
+        const result = await resolver.resolve('{{Network().supports}}', context)
+        expect(result).toBe(mockNetwork.supports)
+      })
+  
+      it('should return gasLimit for valid network', async () => {
+        const result = await resolver.resolve('{{Network().gasLimit}}', context)
+        expect(result).toBe(mockNetwork.gasLimit)
+      })
+
+      it('should return testnet for valid network', async () => {
+        // Note: Expect true because testnet is not set
+        const result = await resolver.resolve('{{Network().testnet}}', context)
+        expect(result).toBe(false)
+      })
+
+      it('should return evmVersion for valid network', async () => {
+        const result = await resolver.resolve('{{Network().evmVersion}}', context)
+        expect(result).toBe(mockNetwork.evmVersion)
+      })
+    })
+
+    describe('invalid Network expressions', () => {
+      it('should fail for invalid property', async () => {
+        await expect(resolver.resolve('{{Network().invalid}}', context))
+          .rejects.toThrow('Property "invalid" does not exist on network')
+      })
+
+      it('should fail for undefined property', async () => {
+        await expect(resolver.resolve('{{Network().undefined}}', context))
+          .rejects.toThrow('Property "undefined" does not exist on network')
+      })
+
+      it('should fail for network with reference', async () => {
+        await expect(resolver.resolve('{{Network(testnet).name}}', context))
+          .rejects.toThrow('Failed to resolve expression \"{{Network(testnet).name}}\". It is not a valid Contract(...) or Network() reference, local scope variable, constant, or a known output.')
+      })
+    })
+  })
+
   describe('call', () => {
     let testContractAddress: string
     let anvilProvider: ethers.JsonRpcProvider

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 = []
+  }
 }

package/src/lib/core/resolver.ts

@@ -5,16 +5,17 @@ import {
   AbiEncodeValue,
   AbiPackValue,
   ConstructorEncodeValue,
+  ComputeCreateValue,
   ComputeCreate2Value,
   ReadBalanceValue,
   BasicArithmeticValue,
   CallValue,
-  ContractExistsCondition,
   ContractExistsValue,
   JobCompletedValue,
   ReadJsonValue,
 } from '../types'
 import { ExecutionContext } from './context'
+import { isAddress, isBigNumberish, isBytesLike } from '../utils/assertion'
 
 /**
  * A scope for resolving local variables, such as template arguments.
@@ -115,6 +116,22 @@ export class ValueResolver {
       return value
     }
 
+    // Check for Network(...) property access
+    const networkMatch = expression.match(/^Network\(\)\.(.\w+)$/)
+    if (networkMatch) {
+      const [, property] = networkMatch
+      const network = context.getNetwork()
+      if (property === 'testnet') {
+        // Special case for testnet property. Default to false if not set.
+        return !!network.testnet
+      }
+      const value = (network as any)[property]
+      if (value === undefined) {
+        throw new Error(`Property "${property}" does not exist on network`)
+      }
+      return value
+    }
+
     // Check scope for local variables (template arguments) first
     if (scope.has(expression)) {
       return scope.get(expression)
@@ -131,7 +148,7 @@ export class ValueResolver {
       return context.getOutput(expression)
     } catch (e) {
       // Provide a more helpful error if an unresolved reference is found
-      throw new Error(`Failed to resolve expression "{{${expression}}}". It is not a valid Contract(...) reference, local scope variable, constant, or a known output.`)
+      throw new Error(`Failed to resolve expression "{{${expression}}}". It is not a valid Contract(...) or Network() reference, local scope variable, constant, or a known output.`)
     }
   }
 
@@ -154,6 +171,8 @@ export class ValueResolver {
         return this.resolveAbiPack(resolvedArgs as AbiPackValue['arguments'])
       case 'constructor-encode':
         return this.resolveConstructorEncode(resolvedArgs as ConstructorEncodeValue['arguments'])
+      case 'compute-create':
+        return this.resolveComputeCreate(resolvedArgs as ComputeCreateValue['arguments'])
       case 'compute-create2':
         return this.resolveComputeCreate2(resolvedArgs as ComputeCreate2Value['arguments'])
       case 'read-balance':
@@ -260,7 +279,7 @@ export class ValueResolver {
     }
 
     // Validate that creation code is valid bytecode
-    if (!ethers.isBytesLike(creationCode)) {
+    if (!isBytesLike(creationCode)) {
       throw new Error(`Invalid creation code: ${creationCode}`)
     }
 
@@ -280,18 +299,36 @@ export class ValueResolver {
     return '0x' + cleanCreationCode + cleanEncodedArgs
   }
 
+  private resolveComputeCreate(args: ComputeCreateValue['arguments']): string {
+    const { deployerAddress, nonce } = args
+    // Check if the deployer address is a valid address
+    if (!isAddress(deployerAddress)) {
+      throw new Error(`Invalid deployer address: ${deployerAddress}`)
+    }
+    // Check if the nonce is a valid value
+    if (!isBigNumberish(nonce)) {
+      throw new Error(`Invalid nonce: ${nonce}`)
+    }
+    const bnNonce = ethers.toBigInt(nonce)
+    // Create the create address
+    return ethers.getCreateAddress({
+      from: deployerAddress,
+      nonce: bnNonce,
+    })
+  }
+
   private resolveComputeCreate2(args: ComputeCreate2Value['arguments']): string {
     const { deployerAddress, salt, initCode } = args
     // Check if the deployer address is a valid address
-    if (!ethers.isAddress(deployerAddress)) {
+    if (!isAddress(deployerAddress)) {
       throw new Error(`Invalid deployer address: ${deployerAddress}`)
     }
     // Check if the salt is a valid bytes value
-    if (!ethers.isBytesLike(salt)) {
+    if (!isBytesLike(salt)) {
       throw new Error(`Invalid salt: ${salt}`)
     }
     // Check if the init code is a valid bytes value
-    if (!ethers.isBytesLike(initCode)) {
+    if (!isBytesLike(initCode)) {
       throw new Error(`Invalid init code: ${initCode}`)
     }
     // Hash the init code using Keccak256
@@ -304,7 +341,7 @@ export class ValueResolver {
     // Check if the address is a valid address
     const addressValue = args.address as any
 
-    if (!ethers.isAddress(addressValue)) {
+    if (!isAddress(addressValue)) {
       throw new Error(`Invalid address: ${addressValue}`)
     }
 
@@ -349,7 +386,7 @@ export class ValueResolver {
     }
 
     // Validate that the target address is a valid Ethereum address
-    if (!ethers.isAddress(to)) {
+    if (!isAddress(to)) {
       throw new Error(`call: invalid target address: ${to}`)
     }
 
@@ -407,7 +444,7 @@ export class ValueResolver {
   private async resolveContractExists(args: ContractExistsValue['arguments'], context: ExecutionContext): Promise<boolean> {
     const { address } = args
 
-    if (!ethers.isAddress(address)) {
+    if (!isAddress(address)) {
       throw new Error(`contract-exists: invalid address: ${address}`)
     }
 

package/src/lib/deployer.ts

@@ -52,6 +52,9 @@ export interface DeployerOptions {
 
   /** Optional: Show end-of-run summary (default: true). */
   showSummary?: boolean
+
+  /** Optional: Convert verification errors to warnings instead of failing (default: false). */
+  ignoreVerifyErrors?: boolean
 }
 
 /**
@@ -157,7 +160,8 @@ export class Deployer {
       const engine = new ExecutionEngine(this.loader.templates, {
         eventEmitter: this.events,
         verificationRegistry,
-        noPostCheckConditions: this.noPostCheckConditions
+        noPostCheckConditions: this.noPostCheckConditions,
+        ignoreVerifyErrors: this.options.ignoreVerifyErrors ?? false
       })
       
       // Track if any jobs have failed
@@ -312,6 +316,11 @@ export class Deployer {
       // 5. Write results to output files.
       await this.writeOutputFiles()
 
+      // Show verification warnings report if ignoreVerifyErrors is enabled
+      if (this.options.ignoreVerifyErrors) {
+        this.emitVerificationWarningsReport(engine)
+      }
+
       // Emit end-of-run summary before final status
       if (this.showSummary) {
         this.emitRunSummary(hasFailures)
@@ -423,6 +432,24 @@ export class Deployer {
     this.events.emitEvent(summaryEvent)
   }
 
+  /**
+   * Emit verification warnings report when ignoreVerifyErrors is enabled
+   */
+  private emitVerificationWarningsReport(engine: ExecutionEngine): void {
+    const warnings = engine.getVerificationWarnings()
+    
+    if (warnings.length > 0) {
+      this.events.emitEvent({
+        type: 'verification_warnings_report',
+        level: 'warn',
+        data: {
+          totalWarnings: warnings.length,
+          warnings: warnings
+        }
+      })
+    }
+  }
+
   /**
    * Determines the final, ordered list of jobs to execute based on user input.
    * If a user requests specific jobs, this ensures all their dependencies are also included.

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

@@ -266,6 +266,30 @@ export class CLIEventAdapter {
         // Keep short to reduce noise
         console.log(chalk.gray(`        Verification retry ${event.data.attempt}/${event.data.maxRetries}: ${event.data.error}`))
         break
+
+      case 'verification_skipped':
+        console.log(chalk.yellow(`        ⚠️  ${event.data.reason}`))
+        break
+
+      case 'verification_warnings_report':
+        // Display detailed verification warnings report
+        console.log(chalk.yellow('\n📋 Verification Warnings Report'))
+        console.log(chalk.yellow(`   Total warnings: ${event.data.totalWarnings}`))
+        console.log('')
+        
+        if (event.data.warnings && event.data.warnings.length > 0) {
+          for (const warning of event.data.warnings) {
+            console.log(chalk.red(`   ❌ ${warning.actionName} (${warning.contractName})`))
+            console.log(chalk.gray(`      Address: ${warning.address}`))
+            console.log(chalk.gray(`      Platform: ${warning.platform}`))
+            if (warning.networkName) {
+              console.log(chalk.gray(`      Network: ${warning.networkName}`))
+            }
+            console.log(chalk.gray(`      Error: ${warning.error}`))
+            console.log('')
+          }
+        }
+        break
       case 'contract_created':
         console.log(chalk.gray(`        contract: ${event.data.contractAddress}`))
         break

package/src/lib/events/types.ts

@@ -429,6 +429,32 @@ export interface VerificationRetryEvent extends BaseEvent {
   }
 }
 
+export interface VerificationSkippedEvent extends BaseEvent {
+  type: 'verification_skipped'
+  level: 'warn'
+  data: {
+    actionName: string
+    reason: string
+  }
+}
+
+export interface VerificationWarningsReportEvent extends BaseEvent {
+  type: 'verification_warnings_report'
+  level: 'warn'
+  data: {
+    totalWarnings: number
+    warnings: Array<{
+      actionName: string
+      address: string
+      contractName: string
+      platform: string
+      error: string
+      jobName?: string
+      networkName?: string
+    }>
+  }
+}
+
 // End-of-run summary
 export interface RunSummaryEvent extends BaseEvent {
   type: 'run_summary'
@@ -488,5 +514,7 @@ export type DeploymentEvent =
   | VerificationSubmittedEvent
   | VerificationCompletedEvent
   | VerificationFailedEvent
-  | VerificationRetryEvent 
+  | VerificationRetryEvent
+  | VerificationSkippedEvent
+  | VerificationWarningsReportEvent
   | RunSummaryEvent