@0xsequence/catapult 1.3.5 → 1.3.7

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

@@ -1492,7 +1492,7 @@ describe('ExecutionEngine', () => {
       }
 
       await expect((engine as any).executeAction(action, context, new Map())).rejects.toThrow(new Error(`Nick's method test failed for action "nick-test-fail-twice"`))
-      await expect((engine as any).executeAction(action, context, new Map())).rejects.toThrow(new Error('Nick\'s method test already performed this run'))
+      await expect((engine as any).executeAction(action, context, new Map())).rejects.toThrow(new Error('Nick\'s method test already failed this run'))
     })
 
     it('should prevent passing Nick\'s method from being tested twice', async () => {

package/src/lib/core/engine.ts

@@ -29,7 +29,7 @@ export class ExecutionEngine {
   private readonly noPostCheckConditions: boolean
   private readonly allowMultipleNicksMethodTests: boolean
   private readonly ignoreVerifyErrors: boolean
-  private nicksMethodTested: boolean = false
+  private nicksMethodResult: boolean | undefined
   private verificationWarnings: Array<{
     actionName: string
     address: string
@@ -464,17 +464,17 @@ export class ExecutionEngine {
         
         // Handle gas limit with optional multiplier
         const network = context.getNetwork()
+        const signer = await context.getResolvedSigner()
         if (network.gasLimit) {
           const baseGasLimit = network.gasLimit
           txParams.gasLimit = gasMultiplier ? Math.floor(baseGasLimit * gasMultiplier) : baseGasLimit
         } else if (gasMultiplier) {
           // If gasMultiplier is specified but no network gasLimit, estimate gas first
-          const signer = await context.getResolvedSigner()
           const estimatedGas = await signer.estimateGas({ to, data, value })
           txParams.gasLimit = Math.floor(Number(estimatedGas) * gasMultiplier)
         }
         
-        const signer = await context.getResolvedSigner()
+        await this.checkFundsForTransaction(actionName, txParams, context, signer)
         const tx = await signer.sendTransaction(txParams)
         
         this.events.emitEvent({
@@ -795,17 +795,17 @@ export class ExecutionEngine {
         
         // Handle gas limit with optional multiplier
         const network = context.getNetwork()
+        const signer = await context.getResolvedSigner()
         if (network.gasLimit) {
           const baseGasLimit = network.gasLimit
           txParams.gasLimit = gasMultiplier ? Math.floor(baseGasLimit * gasMultiplier) : baseGasLimit
         } else if (gasMultiplier) {
           // If gasMultiplier is specified but no network gasLimit, estimate gas first
-          const signer = await context.getResolvedSigner()
-          const estimatedGas = await signer.estimateGas({ to: null, data, value })
+          const estimatedGas = await signer.estimateGas(txParams)
           txParams.gasLimit = Math.floor(Number(estimatedGas) * gasMultiplier)
         }
-        
-        const signer = await context.getResolvedSigner()
+
+        await this.checkFundsForTransaction(actionName, txParams, context, signer)
         const tx = await signer.sendTransaction(txParams)
         
         this.events.emitEvent({
@@ -855,17 +855,19 @@ export class ExecutionEngine {
         break
       }
       case 'test-nicks-method': {
-        if (this.nicksMethodTested && !this.allowMultipleNicksMethodTests) {
-          try {
-            if (context.getOutput(`${action.name}.success`) === true) {
-              // Return previous result
-              break
-            }
-          } catch (e) {
-            throw new Error(`Nick's method test already performed this run`)
+        if (this.nicksMethodResult !== undefined && !this.allowMultipleNicksMethodTests) {
+          if (this.nicksMethodResult === false) {
+            throw new Error(`Nick's method test already failed this run`)
           }
+          this.events.emitEvent({
+            type: 'debug_info',
+            level: 'debug',
+            data: {
+              message: `Nick's method test already passed this run`,
+            },
+          })
+          break
         }
-        this.nicksMethodTested = true
 
         // Default bytecode if none provided
         const defaultBytecode = '0x608060405234801561001057600080fd5b5061013d806100206000396000f3fe60806040526004361061001e5760003560e01c80639c4ae2d014610023575b600080fd5b6100cb6004803603604081101561003957600080fd5b81019060208101813564010000000081111561005457600080fd5b82018360208201111561006657600080fd5b8035906020019184600183028401116401000000008311171561008857600080fd5b91908080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525092955050913592506100cd915050565b005b60008183516020850134f56040805173ffffffffffffffffffffffffffffffffffffffff83168152905191925081900360200190a050505056fea264697066735822122033609f614f03931b92d88c309d698449bb77efcd517328d341fa4f923c5d8c7964736f6c63430007060033'
@@ -884,6 +886,7 @@ export class ExecutionEngine {
         const fundingAmount = resolvedFundingAmount ? validateBigNumberish(resolvedFundingAmount, actionName, 'fundingAmount') : undefined
         
         const success = await this.testNicksMethod(bytecode, context, gasPrice, gasLimit, fundingAmount)
+        this.nicksMethodResult = success
         
         if (!success) {
           throw new Error(`Nick's method test failed for action "${actionName}"`)
@@ -1700,6 +1703,61 @@ export class ExecutionEngine {
     return sorted
   }
 
+  /**
+   * Checks if the signer has enough funds to cover the estimated cost of the transaction.
+   * Returns true if the signer has enough funds, false if the signer does not have enough funds, and null if no gas price is available.
+   */
+  private async checkFundsForTransaction(actionName: string, txParams: ethers.TransactionRequest, context: ExecutionContext, signer: ethers.Signer): Promise<boolean | null> {
+    try {
+      const gasPrice = txParams.gasPrice || await context.provider.getFeeData().then(data => data.gasPrice)
+      if (!gasPrice) {
+        this.events.emitEvent({
+          type: 'debug_info',
+          level: 'warn',
+          data: {
+            actionName: actionName,
+            message: `No gas price available`
+          }
+        })
+        return null
+      }
+      const gasLimit = txParams.gasLimit || await signer.estimateGas(txParams)
+      const requiredETH = BigInt(gasLimit) * BigInt(gasPrice)
+      const signerBalance = await context.provider.getBalance(await signer.getAddress())
+      this.events.emitEvent({
+        type: 'debug_info',
+          level: 'debug',
+          data: {
+            actionName: actionName,
+            message: `Transaction ${txParams.gasLimit ? 'set' : 'estimated'} gas limit: ${gasLimit}, ${txParams.gasPrice ? 'set' : 'estimated'} gas price: ${ethers.formatUnits(gasPrice, 'gwei')} gwei, required ETH: ${ethers.formatEther(requiredETH)}`
+          }
+        })
+      if (signerBalance < requiredETH) {
+        this.events.emitEvent({
+        type: 'debug_info',
+          level: 'warn',
+          data: {
+            actionName: actionName,
+            message: `Insufficient funds: signer has ${ethers.formatEther(signerBalance)} ETH but estimated cost is ${ethers.formatEther(requiredETH)} ETH`
+          }
+        })
+        return false
+      } else {
+        return true
+      }
+    } catch (error) {
+      this.events.emitEvent({
+        type: 'debug_info',
+        level: 'warn',
+        data: {
+          actionName: actionName,
+          message: "Error checking signer balance: " + (error instanceof Error ? error.message : String(error))
+        }
+      })
+    }
+    return null
+  }
+
   /**
    * Get all verification warnings that were collected when ignoreVerifyErrors is enabled
    */

package/src/lib/core/resolver.ts

@@ -117,7 +117,7 @@ export class ValueResolver {
     }
 
     // Check for Network(...) property access
-    const networkMatch = expression.match(/^Network\(\)\.(.\w+)$/)
+    const networkMatch = expression.match(/^Network\(\)\.(\w+)$/)
     if (networkMatch) {
       const [, property] = networkMatch
       const network = context.getNetwork()
@@ -187,6 +187,8 @@ export class ValueResolver {
         return this.resolveJobCompleted(resolvedArgs as JobCompletedValue['arguments'], context)
       case 'read-json':
         return this.resolveReadJson(resolvedArgs as ReadJsonValue['arguments'])
+      case 'resolve-json':
+        return this.resolveJsonValue(resolvedArgs, context)
       default:
         throw new Error(`Unknown value resolver type: ${(obj as any).type}`)
     }
@@ -513,6 +515,21 @@ export class ValueResolver {
     }
   }
 
+  private async resolveJsonValue(args: any, context: ExecutionContext): Promise<any> {
+    if (Array.isArray(args)) {
+      return Promise.all(args.map(v => this.resolveJsonValue(v, context)))
+    } else if (typeof args === 'object' && args !== null) {
+      const resolved: Record<string, any> = {}
+      for (const [k, v] of Object.entries(args)) {
+        resolved[k] = await this.resolveJsonValue(v, context)
+      }
+      return resolved
+    } else {
+      // For primitive values, resolve them using the main resolve method
+      return this.resolve(args, context)
+    }
+  }
+
   /**
    * Helper to recursively resolve the `arguments` field of any `ValueResolver` object.
    * @private

package/src/lib/deployer.ts

@@ -688,16 +688,26 @@ export class Deployer {
 
   /**
    * Populates the execution context with outputs from previously executed dependent jobs.
+   * Throws an error if any dependency failed.
    */
   private populateContextWithDependentJobOutputs(job: Job, context: ExecutionContext, network: Network): void {
     if (!job.depends_on) return
 
     for (const dependentJobName of job.depends_on) {
       const dependentJobResults = this.results.get(dependentJobName)
-      if (!dependentJobResults) continue
+      if (!dependentJobResults) {
+        throw new Error(`Job "${job.name}" depends on "${dependentJobName}", but "${dependentJobName}" has not been executed yet.`)
+      }
 
       const networkResult = dependentJobResults.outputs.get(network.chainId)
-      if (!networkResult || networkResult.status !== 'success') continue
+      if (!networkResult) {
+        throw new Error(`Job "${job.name}" depends on "${dependentJobName}", but "${dependentJobName}" has not been executed on network ${network.name} (chainId: ${network.chainId}).`)
+      }
+
+      if (networkResult.status !== 'success') {
+        const errorMessage = typeof networkResult.data === 'string' ? networkResult.data : 'Unknown error'
+        throw new Error(`Job "${job.name}" depends on "${dependentJobName}", but "${dependentJobName}" failed: ${errorMessage}`)
+      }
 
       // Add outputs with job name prefixes for cross-job access
       const outputs = networkResult.data as Map<string, unknown>