@0xsequence/catapult 1.3.13 → 1.3.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/catapult",
-  "version": "1.3.13",
+  "version": "1.3.15",
   "description": "Ethereum contract deployment CLI tool",
   "main": "dist/index.js",
   "bin": {

package/src/lib/__tests__/deployer.spec.ts

@@ -460,6 +460,34 @@ describe('Deployer', () => {
           'deploy2.address': '0xdeploy2'
         })
       })
+
+      it('should keep outputs empty when only skipped opt-in actions produce no keys', async () => {
+        const jobWithSkippedOptIn: Job = {
+          name: 'job-skipped-opt-in',
+          version: '1.0.0',
+          description: 'Job where the only opted-in action produced no outputs',
+          actions: [
+            { name: 'deploy-action', template: 'template1', arguments: {}, output: false },
+            { name: 'skipped-action', template: 'template1', arguments: {}, output: true }
+          ]
+        }
+
+        mockLoader.jobs.clear()
+        mockLoader.jobs.set('job-skipped-opt-in', jobWithSkippedOptIn)
+        mockGraph.getExecutionOrder.mockReturnValue(['job-skipped-opt-in'])
+
+        mockContext.getOutputs.mockReturnValue(new Map<string, any>([
+          ['deploy-action.address', '0xdeployaddress']
+        ]))
+
+        const deployer = new Deployer(deployerOptions)
+        await deployer.run()
+
+        const outputCall = mockFs.writeFile.mock.calls[0]
+        const outputContent = JSON.parse(outputCall[1] as string)
+
+        expect(outputContent.networks[0].outputs).toEqual({})
+      })
     })
 
     describe('error handling', () => {

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

@@ -0,0 +1,37 @@
+import { ethers } from 'ethers'
+import { ExecutionContext } from '../context'
+import { Network } from '../../types'
+
+describe('ExecutionContext', () => {
+  const network: Network = {
+    name: 'test',
+    chainId: 31337,
+    rpcUrl: 'http://127.0.0.1:8545'
+  }
+
+  const contractRepository = {} as any
+
+  it('wraps private-key signers in a NonceManager', async () => {
+    const context = new ExecutionContext(
+      network,
+      '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+      contractRepository
+    )
+
+    const signer = await context.getResolvedSigner()
+    expect(signer).toBeInstanceOf(ethers.NonceManager)
+  })
+
+  it('wraps promised signers in a NonceManager when first resolved', async () => {
+    const getSignerSpy = jest.spyOn(ethers.JsonRpcProvider.prototype, 'getSigner')
+    getSignerSpy.mockResolvedValue(
+      ethers.Wallet.createRandom().connect(new ethers.JsonRpcProvider(network.rpcUrl)) as any
+    )
+
+    const context = new ExecutionContext(network, undefined, contractRepository)
+
+    await expect(context.getResolvedSigner()).resolves.toBeInstanceOf(ethers.NonceManager)
+
+    getSignerSpy.mockRestore()
+  })
+})

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

@@ -102,6 +102,28 @@ describe('ValueResolver', () => {
       expect(await resolver.resolve(valueFalse, context)).toBe(false)
     })
 
+    it('should treat nullish nested values as non-equal without throwing', async () => {
+      const value: BasicArithmeticValue = {
+        type: 'basic-arithmetic',
+        arguments: {
+          operation: 'eq',
+          values: [
+            {
+              type: 'call',
+              arguments: {
+                to: '0x1234567890123456789012345678901234567890',
+                signature: 'imageHash() returns (bytes32)',
+                values: [],
+              },
+            },
+            '0xfd72d46fd0d0a98780315f81790f051356f2f3101af4b5c3fb1c6da3237fb765',
+          ],
+        },
+      }
+
+      await expect(resolver.resolve(value, context)).resolves.toBe(false)
+    })
+
     it('should correctly evaluate "gt" (greater than)', async () => {
       const valueTrue: BasicArithmeticValue = { type: 'basic-arithmetic', arguments: { operation: 'gt', values: [10, 5] } }
       const valueFalse: BasicArithmeticValue = { type: 'basic-arithmetic', arguments: { operation: 'gt', values: [10, 10] } }

package/src/lib/core/context.ts

@@ -33,11 +33,11 @@ export class ExecutionContext {
 
    // Determine the signer
    if (privateKey) {
-     this.signer = new ethers.Wallet(privateKey, this.provider)
+     this.signer = new ethers.NonceManager(new ethers.Wallet(privateKey, this.provider))
    } else if (network.rpcUrl) {
      // If no private key, but RPC URL is provided, get a signer from the provider.
      // This returns a Promise that we need to resolve on first use.
-     this.signer = this.provider.getSigner() // Keep as Promise
+     this.signer = this.provider.getSigner().then(signer => new ethers.NonceManager(signer)) // Keep as Promise
    } else {
      throw new Error('A private key must be provided or an RPC URL must be configured to obtain a signer for the network.')
    }
@@ -124,4 +124,4 @@ export class ExecutionContext {
       // Ignore errors during cleanup
     }
   }
-}
+}

package/src/lib/core/resolver.ts

@@ -362,19 +362,42 @@ export class ValueResolver {
       throw new Error(`basic-arithmetic requires at least 2 values, got ${args.values?.length ?? 0}`)
     }
 
+    switch (args.operation) {
+      // Equality (return boolean, tolerate nullish / non-numeric values)
+      case 'eq': {
+        const [a, b] = args.values
+        return this.valuesEqual(a, b)
+      }
+      case 'neq': {
+        const [a, b] = args.values
+        return !this.valuesEqual(a, b)
+      }
+
+      // Arithmetic (return string)
+      case 'add':
+      case 'sub':
+      case 'mul':
+      case 'div':
+      case 'gt':
+      case 'lt':
+      case 'gte':
+      case 'lte':
+        break
+
+      default:
+        throw new Error(`Unsupported basic-arithmetic operation: ${args.operation}`)
+    }
+
     const numbers = args.values.map(v => ethers.toBigInt(v))
     const [a, b] = numbers
 
     switch (args.operation) {
-      // Arithmetic (return string)
       case 'add': return numbers.reduce((sum, current) => sum + current).toString()
       case 'sub': return (a - b).toString()
       case 'mul': return (a * b).toString()
       case 'div': return (a / b).toString()
 
       // Comparison (return boolean)
-      case 'eq':  return a === b
-      case 'neq': return a !== b
       case 'gt':  return a > b
       case 'lt':  return a < b
       case 'gte': return a >= b
@@ -385,6 +408,30 @@ export class ValueResolver {
     }
   }
 
+  private valuesEqual(a: any, b: any): boolean {
+    if (a == null || b == null) {
+      return a == null && b == null
+    }
+
+    if (isBigNumberish(a) && isBigNumberish(b)) {
+      return ethers.toBigInt(a) === ethers.toBigInt(b)
+    }
+
+    if (typeof a === 'string' && typeof b === 'string') {
+      return a === b
+    }
+
+    if (typeof a === 'boolean' && typeof b === 'boolean') {
+      return a === b
+    }
+
+    if ((typeof a === 'object' && a !== null) || (typeof b === 'object' && b !== null)) {
+      return JSON.stringify(a) === JSON.stringify(b)
+    }
+
+    return a === b
+  }
+
   private async resolveCall(args: CallValue['arguments'], context: ExecutionContext): Promise<any> {
     const { to, signature, values } = args
 

package/src/lib/deployer.ts

@@ -879,8 +879,10 @@ export class Deployer {
 
     // 3) Exclude any actions explicitly marked false (they won't be included by rules above anyway)
 
-    // If we have any inclusions (custom maps or trues), return them
-    if (result.size > 0) {
+    const hasExplicitOutputSelection = actionsWithCustomMap.length > 0 || actionsWithTrue.length > 0
+
+    // If the job has any explicit output selection, return the selected outputs even when empty.
+    if (hasExplicitOutputSelection) {
       // Additionally, filter out any accidentally included outputs from actions marked false
       for (const falseActionName of actionsWithFalse) {
         for (const key of Array.from(result.keys())) {
@@ -976,4 +978,4 @@ export class Deployer {
     // Return all entries: successes first, then errors
     return [...successEntries, ...errorEntries]
   }
-}
+}