@0xsequence/catapult 1.3.2 → 1.3.4

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(', ')}`)
+            }
           }
         }
 
@@ -1126,9 +1190,76 @@ export class ExecutionEngine {
       
       // Generate a valid ECDSA signature using Nick's method approach
       const result = await this.generateNicksMethodTransaction(bytecode, defaultGasPrice, defaultGasLimit)
-      const rawTx = result.rawTx
+      const {signedTx, unsignedTx} = result
       eoaAddress = result.eoaAddress
       wallet = result.wallet
+
+      // Simulate the contract creation transaction
+      try {
+        const simulationTx = {
+          ...unsignedTx,
+          from: eoaAddress,
+        };
+
+        if (unsignedTx.gasPrice) {
+          // Check gas price
+          const gasPrice = await context.provider.getFeeData().then(data => data.gasPrice)
+          if (!gasPrice) {
+            this.events.emitEvent({
+              type: "debug_info",
+              level: "debug",
+              data: {
+                message: `Legacy gas price not available.`,
+              },
+            });
+          } else if (BigInt(unsignedTx.gasPrice.toString()) < gasPrice) {
+            this.events.emitEvent({
+              type: "debug_info",
+              level: "warn",
+              data: {
+                message: `Gas price (${unsignedTx.gasPrice}) is lower than the current gas price (${gasPrice}). This may cause the transaction to not be mined.`,
+              },
+            });
+          }
+        }
+
+        if (simulationTx.gasLimit) {
+          // Simulate the transaction expected gas usage
+          const estimatedGas = await context.provider.estimateGas(simulationTx);
+          const estimatedGasStr = estimatedGas.toString();
+          const simulationTxGasLimitStr = simulationTx.gasLimit.toString();
+          if (estimatedGas > BigInt(simulationTxGasLimitStr)) {
+            this.events.emitEvent({
+              type: "debug_info",
+              level: "warn",
+              data: {
+                message: `Estimated gas (${estimatedGasStr}) is greater than gas provided in the transaction (${simulationTxGasLimitStr}). This may cause the transaction to revert.`,
+              },
+            });
+          } else {
+            this.events.emitEvent({
+              type: "debug_info",
+              level: "debug",
+              data: {
+                message: `Estimated gas: ${estimatedGasStr}, Gas provided: ${simulationTxGasLimitStr}`,
+              },
+            });
+          }
+        }
+      } catch (simulationError) {
+        this.events.emitEvent({
+          type: "debug_info",
+          level: "warn",
+          data: {
+            message: `Simulation failed: ${
+              simulationError instanceof Error
+                ? simulationError.message
+                : String(simulationError)
+            }`,
+          },
+        });
+        // Continue with the test even if simulation fails
+      }
       
       this.events.emitEvent({
         type: 'debug_info',
@@ -1221,11 +1352,11 @@ export class ExecutionEngine {
         type: 'debug_info',
         level: 'debug',
         data: {
-          message: `[NICK'S METHOD DEBUG] Broadcasting Nick's method transaction. RawTx: ${rawTx.substring(0, 100)}...`
+          message: `[NICK'S METHOD DEBUG] Broadcasting Nick's method transaction. RawTx: ${signedTx.substring(0, 100)}...`
         }
       })
       
-      const deployTx = await context.provider.broadcastTransaction(rawTx)
+      const deployTx = await context.provider.broadcastTransaction(signedTx)
       
       this.events.emitEvent({
         type: 'debug_info',
@@ -1322,7 +1453,7 @@ export class ExecutionEngine {
     bytecode: string,
     gasPrice: ethers.BigNumberish,
     gasLimit: ethers.BigNumberish
-  ): Promise<{ rawTx: string; eoaAddress: string; wallet: ethers.HDNodeWallet }> {
+  ): Promise<{ unsignedTx: ethers.TransactionRequest; signedTx: string; eoaAddress: string; wallet: ethers.HDNodeWallet }> {
     // Generate a random private key for the test
     const wallet = ethers.Wallet.createRandom()
     
@@ -1346,9 +1477,10 @@ export class ExecutionEngine {
     const eoaAddress = parsedTx.from!
     
     return {
-      rawTx: signedTx,
-      eoaAddress: eoaAddress,
-      wallet: wallet
+      unsignedTx,
+      signedTx,
+      eoaAddress,
+      wallet,
     }
   }
 
@@ -1372,9 +1504,26 @@ export class ExecutionEngine {
     const connectedWallet = wallet.connect(context.provider)
     
     // Estimate gas for a simple transfer
-    const gasPrice = await context.provider.getFeeData().then(data => data.gasPrice || ethers.parseUnits('20', 'gwei'))
+    const feeData = await context.provider.getFeeData()
+    const txGas = feeData.maxFeePerGas ? {
+      maxFeePerGas: feeData.maxFeePerGas,
+      maxPriorityFeePerGas: feeData.maxPriorityFeePerGas || ethers.parseUnits('20', 'gwei')
+    } : {
+      gasPrice: feeData.gasPrice || undefined,
+    }
+    const effectiveGasPrice = txGas.maxFeePerGas || txGas.gasPrice
+    if (!effectiveGasPrice) {
+      this.events.emitEvent({
+        type: 'action_failed',
+        level: 'error',
+        data: {
+          message: `No gas price available`
+        }
+      })
+      return
+    }
     const gasLimit = 21000n // Standard gas limit for ETH transfer
-    const gasCost = BigInt(gasPrice.toString()) * gasLimit
+    const gasCost = effectiveGasPrice * gasLimit
     
     // Check if we have enough balance to cover gas costs
     if (remainingBalance <= gasCost) {
@@ -1406,8 +1555,8 @@ export class ExecutionEngine {
     const returnTx = await connectedWallet.sendTransaction({
       to: await (await context.getResolvedSigner()).getAddress(),
       value: amountToSend,
-      gasPrice: gasPrice,
-      gasLimit: gasLimit
+      gasLimit: gasLimit,
+      ...txGas,
     })
     
     await returnTx.wait()
@@ -1550,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.
@@ -154,6 +155,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 +263,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 +283,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 +325,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 +370,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 +428,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/__tests__/event-system.spec.ts

@@ -11,7 +11,7 @@ describe('Event System', () => {
   beforeEach(() => {
     eventEmitter = new DeploymentEventEmitter()
     cliAdapter = new CLIEventAdapter(eventEmitter, 3)
-    
+
     // Mock console methods
     consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
     consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
@@ -339,5 +339,54 @@ describe('Event System', () => {
 
       expect(handler).not.toHaveBeenCalled()
     })
+
+    it('should respect debug_info event level for verbosity filtering', () => {
+      // Test with verbosity 0 (default) - should NOT show any debug_info events
+      cliAdapter.setVerbosity(0)
+
+      eventEmitter.emitEvent({
+        type: 'debug_info',
+        level: 'warn',
+        data: {
+          message: 'This warning should NOT be shown at verbosity 0'
+        }
+      })
+
+      expect(consoleLogSpy).not.toHaveBeenCalled()
+
+      // Clear previous calls
+      consoleLogSpy.mockClear()
+
+      // Test with verbosity 3 - should show warn level with correct formatting
+      cliAdapter.setVerbosity(3)
+
+      eventEmitter.emitEvent({
+        type: 'debug_info',
+        level: 'warn',
+        data: {
+          message: 'This warning should be shown at verbosity 3'
+        }
+      })
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[WARN] This warning should be shown at verbosity 3')
+      )
+
+      // Clear previous calls
+      consoleLogSpy.mockClear()
+
+      // Test with verbosity 3 - should show debug level with correct formatting
+      eventEmitter.emitEvent({
+        type: 'debug_info',
+        level: 'debug',
+        data: {
+          message: 'This debug message should be shown at verbosity 3'
+        }
+      })
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[DEBUG] This debug message should be shown at verbosity 3')
+      )
+    })
   })
-}) 
+})

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

@@ -5,7 +5,7 @@ import { DeploymentEventEmitter } from './emitter'
 /**
  * Verbosity levels for filtering console output:
  * 0 (default): Critical info only - errors, warnings, main deployment steps
- * 1 (-v): Add transaction details and verification steps  
+ * 1 (-v): Add transaction details and verification steps
  * 2 (-vv): Add action details and file operations
  * 3 (-vvv): Full debug - show everything including template transitions
  */
@@ -81,7 +81,7 @@ export class CLIEventAdapter {
     if (level1Events.has(eventType)) return 1
     if (level2Events.has(eventType)) return 2
     if (level3Events.has(eventType)) return 3
-    
+
     // Default to level 3 for any new events we haven't categorized
     return 3
   }
@@ -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
@@ -314,7 +338,11 @@ export class CLIEventAdapter {
         break
 
       case 'debug_info':
-        console.log(chalk.gray(`        [DEBUG] ${event.data.message}`))
+        const levelPrefix = event.level.toUpperCase()
+        const levelColor = event.level === 'warn' ? chalk.yellow :
+                          event.level === 'info' ? chalk.blue :
+                          chalk.gray
+        console.log(levelColor(`        [${levelPrefix}] ${event.data.message}`))
         break
 
       default:
@@ -338,4 +366,4 @@ export class CLIEventAdapter {
   public destroy(): void {
     this.emitter.removeAllListeners()
   }
-} 
+}

package/src/lib/events/types.ts

@@ -147,7 +147,7 @@ export interface ActionInfoEvent extends BaseEvent {
 
 export interface DebugInfoEvent extends BaseEvent {
   type: 'debug_info'
-  level: 'debug'
+  level: 'debug' | 'info' | 'warn'
   data: {
     message: string
   }
@@ -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

package/src/lib/std/templates/assured-deployment.yaml

@@ -13,17 +13,18 @@
 # code before the call data, hence the wrapping pattern.
 name: "assured-deployment"
 type: "template"
+description: "Wraps a factory call with a CREATE that runs a minimal assurance program"
 
 arguments:
-  # The address that is expected to exist after the factory call (e.g., CREATE2 result)
   targetAddress:
     type: "address"
-  # The factory that will perform the deployment
+    description: "The address that is expected to exist after the factory call (e.g., CREATE2 result)"
   factoryAddress:
     type: "address"
-  # Encoded call to the factory (e.g., abi-encoded deploy(...))
+    description: "The factory that will perform the deployment"
   callData:
     type: "bytes"
+    description: "The encoded call to the factory (e.g., abi-encoded deploy(...))"
 
 actions:
   - type: "create-contract"