@0xsequence/catapult 1.3.16 → 1.4.0

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

@@ -1679,7 +1679,7 @@ describe('Deployer', () => {
       const jobAResult = results.get('job-a')
       expect(jobAResult).toBeDefined()
       expect(jobAResult.outputs.get(mockNetwork1.chainId).status).toBe('skipped')
-      expect(jobAResult.outputs.get(mockNetwork1.chainId).data).toContain('skipped due to skip condition')
+      expect(jobAResult.outputs.get(mockNetwork1.chainId).data).toContain('skip_condition')
 
       // Verify that job B ran successfully
       const jobBResult = results.get('job-b')
@@ -2090,4 +2090,180 @@ describe('Deployer', () => {
       )
     })
   })
+
+  describe('skip_if functionality', () => {
+    it('should skip job when skip_if condition is true', async () => {
+      const jobWithSkipIf: Job = {
+        name: 'job-with-skip-if',
+        version: '1.0.0',
+        description: 'Job with skip_if condition',
+        skip_if: [{ type: 'contract-exists', arguments: { address: '0xabc' } }],
+        actions: [
+          { name: 'action1', template: 'template1', arguments: {} }
+        ]
+      }
+
+      mockLoader.jobs.clear()
+      mockLoader.jobs.set('job-with-skip-if', jobWithSkipIf)
+      mockGraph.getExecutionOrder.mockReturnValue(['job-with-skip-if'])
+
+      // Mock engine.evaluateSkipConditions to return true (condition met)
+      mockEngine.evaluateSkipConditions = jest.fn().mockResolvedValue(true)
+
+      const deployer = new Deployer(deployerOptions)
+      await deployer.run()
+
+      // Job should be skipped
+      const results = (deployer as any).results
+      const jobResult = results.get('job-with-skip-if')
+      expect(jobResult).toBeDefined()
+      expect(jobResult.outputs.get(mockNetwork1.chainId).status).toBe('skipped')
+      expect(jobResult.outputs.get(mockNetwork1.chainId).data).toContain('skip_if')
+
+      // executeJob should NOT be called for skipped job
+      expect(mockEngine.executeJob).not.toHaveBeenCalled()
+    })
+
+    it('should run job when skip_if condition is false', async () => {
+      const jobWithSkipIf: Job = {
+        name: 'job-with-skip-if-false',
+        version: '1.0.0',
+        description: 'Job with skip_if condition that is false',
+        skip_if: [{ type: 'contract-exists', arguments: { address: '0xabc' } }],
+        actions: [
+          { name: 'action1', template: 'template1', arguments: {} }
+        ]
+      }
+
+      mockLoader.jobs.clear()
+      mockLoader.jobs.set('job-with-skip-if-false', jobWithSkipIf)
+      mockGraph.getExecutionOrder.mockReturnValue(['job-with-skip-if-false'])
+
+      // Mock engine.evaluateSkipConditions to return false (condition not met)
+      mockEngine.evaluateSkipConditions = jest.fn().mockResolvedValue(false)
+
+      const deployer = new Deployer(deployerOptions)
+      await deployer.run()
+
+      // Job should run normally
+      const results = (deployer as any).results
+      const jobResult = results.get('job-with-skip-if-false')
+      expect(jobResult).toBeDefined()
+      expect(jobResult.outputs.get(mockNetwork1.chainId).status).toBe('success')
+
+      // executeJob should be called
+      expect(mockEngine.executeJob).toHaveBeenCalledWith(jobWithSkipIf, expect.anything())
+    })
+
+    it('should skip job when skip_if OR skip_condition is true', async () => {
+      const jobWithBoth: Job = {
+        name: 'job-with-both',
+        version: '1.0.0',
+        description: 'Job with both skip_if and skip_condition',
+        skip_condition: [{ type: 'contract-exists', arguments: { address: '0xabc' } }],
+        skip_if: [{ type: 'job-completed', arguments: { job: 'other-job' } }],
+        actions: [
+          { name: 'action1', template: 'template1', arguments: {} }
+        ]
+      }
+
+      mockLoader.jobs.clear()
+      mockLoader.jobs.set('job-with-both', jobWithBoth)
+      mockGraph.getExecutionOrder.mockReturnValue(['job-with-both'])
+
+      // Mock engine.evaluateSkipConditions to return false for skip_condition but true for skip_if
+      // The combined conditions should be evaluated together
+      mockEngine.evaluateSkipConditions = jest.fn().mockResolvedValue(true)
+
+      const deployer = new Deployer(deployerOptions)
+      await deployer.run()
+
+      // Job should be skipped (skip_if is true)
+      const results = (deployer as any).results
+      const jobResult = results.get('job-with-both')
+      expect(jobResult).toBeDefined()
+      expect(jobResult.outputs.get(mockNetwork1.chainId).status).toBe('skipped')
+
+      // executeJob should NOT be called
+      expect(mockEngine.executeJob).not.toHaveBeenCalled()
+    })
+
+    it('should NOT post-check skip_if after execution (only skip_condition is post-checked)', async () => {
+      // This is the key test: skip_if should NOT cause post-execution failures
+      const jobWithSkipIfOnly: Job = {
+        name: 'job-skip-if-only',
+        version: '1.0.0',
+        description: 'Job with skip_if that remains false after execution',
+        only_networks: [1], // Only run on mainnet to have predictable call count
+        skip_if: [{ type: 'contract-exists', arguments: { address: '0xabc' } }],
+        actions: [
+          { name: 'action1', template: 'template1', arguments: {} }
+        ]
+      }
+
+      mockLoader.jobs.clear()
+      mockLoader.jobs.set('job-skip-if-only', jobWithSkipIfOnly)
+      mockGraph.getExecutionOrder.mockReturnValue(['job-skip-if-only'])
+
+      // Pre-skip: skip_if is false, so job runs
+      mockEngine.evaluateSkipConditions = jest.fn().mockResolvedValue(false)
+
+      // Job runs successfully - no post-check for skip_if
+      mockEngine.executeJob = jest.fn().mockResolvedValue(undefined)
+
+      const deployer = new Deployer(deployerOptions)
+      await deployer.run()
+
+      // Job should succeed (no post-check failure for skip_if)
+      const results = (deployer as any).results
+      const jobResult = results.get('job-skip-if-only')
+      expect(jobResult).toBeDefined()
+      expect(jobResult.outputs.get(mockNetwork1.chainId).status).toBe('success')
+
+      // evaluateSkipConditions called once for pre-skip check (skip_if on mainnet only)
+      // skip_if is NOT post-checked, so no additional calls from engine
+      expect(mockEngine.evaluateSkipConditions).toHaveBeenCalledTimes(1)
+      // executeJob should be called once (job ran on mainnet only)
+      expect(mockEngine.executeJob).toHaveBeenCalledTimes(1)
+    })
+
+    it('should still post-check skip_condition (existing behavior unchanged)', async () => {
+      // Verify that skip_condition still gets post-checked
+      // For this test, we need to use the real ExecutionEngine behavior
+      // Since the mock doesn't easily support this, we'll verify the behavior indirectly
+      
+      // The key is that skip_condition triggers post-check in the engine,
+      // while skip_if does not. This is verified by the engine.spec.ts tests.
+      
+      const jobWithSkipCondition: Job = {
+        name: 'job-skip-condition',
+        version: '1.0.0',
+        description: 'Job with skip_condition',
+        skip_condition: [{ type: 'contract-exists', arguments: { address: '0xabc' } }],
+        actions: [
+          { name: 'action1', template: 'template1', arguments: {} }
+        ]
+      }
+
+      mockLoader.jobs.clear()
+      mockLoader.jobs.set('job-skip-condition', jobWithSkipCondition)
+      mockGraph.getExecutionOrder.mockReturnValue(['job-skip-condition'])
+
+      // Pre-skip: skip_condition is false, so job runs
+      mockEngine.evaluateSkipConditions = jest.fn().mockResolvedValue(false)
+
+      // Job runs successfully
+      mockEngine.executeJob = jest.fn().mockResolvedValue(undefined)
+
+      const deployer = new Deployer(deployerOptions)
+      await deployer.run()
+
+      // Job should succeed in this mock scenario
+      // The actual post-check behavior is tested in engine.spec.ts
+      const results = (deployer as any).results
+      const jobResult = results.get('job-skip-condition')
+      expect(jobResult).toBeDefined()
+      expect(jobResult.outputs.get(mockNetwork1.chainId).status).toBe('success')
+    })
+  })
 })

package/src/lib/__tests__/network-utils.spec.ts

@@ -108,16 +108,15 @@ describe('Network Utils', () => {
   describe('Integration with Run Command', () => {
     it('should create a complete Network object from detected information', async () => {
       const { ethers } = require('ethers')
-      
-      // Mock successful network detection
+
       const mockNetwork = {
         name: 'sepolia',
-        chainId: 11155111
+        chainId: 11155111,
       }
-      
+
       const getNetworkMock = jest.fn().mockResolvedValue(mockNetwork)
       ethers.JsonRpcProvider.mockImplementation(() => ({
-        getNetwork: getNetworkMock
+        getNetwork: getNetworkMock,
       }))
 
       const detectedInfo = await detectNetworkFromRpc('https://sepolia.infura.io/v3/abc123')
@@ -129,7 +128,9 @@ describe('Network Utils', () => {
         rpcUrl: 'https://sepolia.infura.io/v3/abc123',
         supports: detectedInfo.supports || [],
         gasLimit: detectedInfo.gasLimit,
-        testnet: detectedInfo.testnet
+        testnet: detectedInfo.testnet,
+        evmVersion: detectedInfo.evmVersion,
+        params: detectedInfo.params,
       }
 
       expect(customNetwork).toEqual({
@@ -138,22 +139,66 @@ describe('Network Utils', () => {
         rpcUrl: 'https://sepolia.infura.io/v3/abc123',
         supports: [],
         gasLimit: undefined,
-        testnet: undefined
+        testnet: undefined,
+        evmVersion: undefined,
+        params: undefined,
+      })
+    })
+
+    it('should merge params and other yaml fields when chainId matches networks.yaml', async () => {
+      const { ethers } = require('ethers')
+
+      const getNetworkMock = jest.fn().mockResolvedValue({ name: 'unknown', chainId: 137 })
+      ethers.JsonRpcProvider.mockImplementation(() => ({
+        getNetwork: getNetworkMock,
+      }))
+
+      const detectedInfo = await detectNetworkFromRpc('http://127.0.0.1:8545')
+      const knownNetwork: Network = {
+        name: 'Polygon',
+        chainId: 137,
+        rpcUrl: 'https://nodes.sequence.app/polygon/token',
+        supports: ['etherscan_v2', 'sourcify'],
+        testnet: false,
+        evmVersion: 'paris',
+        params: { trailsOnly: false },
+      }
+
+      // Simulate what the run command does
+      const customNetwork: Network = {
+        name: detectedInfo.name || knownNetwork.name || `custom-${detectedInfo.chainId}`,
+        chainId: detectedInfo.chainId!,
+        rpcUrl: 'http://127.0.0.1:8545',
+        supports: detectedInfo.supports || knownNetwork.supports || [],
+        gasLimit: detectedInfo.gasLimit || knownNetwork.gasLimit,
+        testnet: detectedInfo.testnet !== undefined ? detectedInfo.testnet : knownNetwork.testnet,
+        evmVersion: detectedInfo.evmVersion || knownNetwork.evmVersion,
+        params: detectedInfo.params || knownNetwork.params,
+      }
+
+      expect(customNetwork).toEqual({
+        name: 'unknown',
+        chainId: 137,
+        rpcUrl: 'http://127.0.0.1:8545',
+        supports: ['etherscan_v2', 'sourcify'],
+        gasLimit: undefined,
+        testnet: false,
+        evmVersion: 'paris',
+        params: { trailsOnly: false },
       })
     })
 
     it('should handle partial network information gracefully', async () => {
       const { ethers } = require('ethers')
-      
-      // Mock network with minimal information
+
       const mockNetwork = {
         name: 'unknown',
-        chainId: 42
+        chainId: 42,
       }
-      
+
       const getNetworkMock = jest.fn().mockResolvedValue(mockNetwork)
       ethers.JsonRpcProvider.mockImplementation(() => ({
-        getNetwork: getNetworkMock
+        getNetwork: getNetworkMock,
       }))
 
       const detectedInfo = await detectNetworkFromRpc('http://custom-network:8545')
@@ -165,7 +210,9 @@ describe('Network Utils', () => {
         rpcUrl: 'http://custom-network:8545',
         supports: detectedInfo.supports || [],
         gasLimit: detectedInfo.gasLimit,
-        testnet: detectedInfo.testnet
+        testnet: detectedInfo.testnet,
+        evmVersion: detectedInfo.evmVersion,
+        params: detectedInfo.params,
       }
 
       expect(customNetwork).toEqual({
@@ -174,7 +221,9 @@ describe('Network Utils', () => {
         rpcUrl: 'http://custom-network:8545',
         supports: [],
         gasLimit: undefined,
-        testnet: undefined
+        testnet: undefined,
+        evmVersion: undefined,
+        params: undefined,
       })
     })
   })

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

@@ -0,0 +1,208 @@
+import * as fs from 'fs/promises'
+import * as os from 'os'
+import * as path from 'path'
+import { execFile } from 'child_process'
+import { promisify } from 'util'
+import {
+  collectSourceProvenanceEntries,
+  generateBuildInfoFromSourceProvenance,
+  verifySourceProvenance
+} from '../provenance'
+
+const execFileAsync = promisify(execFile)
+
+async function git(cwd: string, args: string[]): Promise<string> {
+  const result = await execFileAsync('git', args, { cwd })
+  return String(result.stdout).trim()
+}
+
+async function writeFile(filePath: string, content: string): Promise<void> {
+  await fs.mkdir(path.dirname(filePath), { recursive: true })
+  await fs.writeFile(filePath, content)
+}
+
+function sourceYaml(repo: string, commit: string, build: string): string {
+  return `
+type: source
+build_info:
+  "./stage1.json":
+    repo: ${JSON.stringify(repo)}
+    commit: ${JSON.stringify(commit)}
+    build: ${JSON.stringify(build)}
+`
+}
+
+function jobYaml(name: string, dependsOn: string[] = []): string {
+  const depends = dependsOn.length > 0 ? `depends_on: ${JSON.stringify(dependsOn)}\n` : ''
+  return `
+name: ${JSON.stringify(name)}
+version: "1.0.0"
+${depends}actions:
+  - name: "noop"
+    type: "static"
+    arguments:
+      value: true
+`
+}
+
+describe('source provenance operations', () => {
+  let tempDir: string
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'catapult-provenance-test-'))
+  })
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true })
+  })
+
+  it('collects source provenance entries even when build-info is missing', async () => {
+    const projectRoot = path.join(tempDir, 'project')
+    const sourcePath = path.join(projectRoot, 'jobs', 'demo', 'build-info', 'source.yaml')
+    await writeFile(sourcePath, sourceYaml('https://github.com/example/repo', 'abc123', 'forge build --build-info'))
+
+    const result = await collectSourceProvenanceEntries(projectRoot)
+
+    expect(result.warnings).toEqual([])
+    expect(result.entries).toHaveLength(1)
+    expect(result.entries[0]).toMatchObject({
+      sourceDocumentPath: sourcePath,
+      buildInfoRef: './stage1.json',
+      buildInfoPath: path.join(projectRoot, 'jobs', 'demo', 'build-info', 'stage1.json')
+    })
+  })
+
+  it('can scope provenance entries to a job and its dependencies', async () => {
+    const projectRoot = path.join(tempDir, 'project')
+    await writeFile(path.join(projectRoot, 'jobs', 'base.yaml'), jobYaml('base'))
+    await writeFile(path.join(projectRoot, 'jobs', 'child.yaml'), jobYaml('child', ['base']))
+    await writeFile(path.join(projectRoot, 'jobs', 'base', 'build-info', 'source.yaml'), sourceYaml('https://github.com/example/base', 'abc123', 'build-base'))
+    await writeFile(path.join(projectRoot, 'jobs', 'child', 'build-info', 'source.yaml'), sourceYaml('https://github.com/example/child', 'def456', 'build-child'))
+
+    const childOnly = await collectSourceProvenanceEntries(projectRoot, {
+      jobs: ['child'],
+      loadStdTemplates: false
+    })
+    const withDependencies = await collectSourceProvenanceEntries(projectRoot, {
+      jobs: ['child'],
+      includeDependencies: true,
+      loadStdTemplates: false
+    })
+
+    expect(childOnly.entries.map(entry => entry.provenance.repo)).toEqual(['https://github.com/example/child'])
+    expect(withDependencies.entries.map(entry => entry.provenance.repo).sort()).toEqual([
+      'https://github.com/example/base',
+      'https://github.com/example/child'
+    ])
+  })
+
+  it('generates missing build-info from a local Git provenance repo', async () => {
+    const { projectRoot, expectedBuildInfo } = await createProjectWithLocalProvenanceRepo()
+
+    const result = await generateBuildInfoFromSourceProvenance(projectRoot)
+    const generatedPath = path.join(projectRoot, 'jobs', 'demo', 'build-info', 'stage1.json')
+    const generatedJson = JSON.parse(await fs.readFile(generatedPath, 'utf-8'))
+
+    expect(result.results).toHaveLength(1)
+    expect(result.results[0].status).toBe('generated')
+    expect(generatedJson).toEqual(expectedBuildInfo)
+  })
+
+  it('verifies generated build-info and reports mismatches', async () => {
+    const { projectRoot } = await createProjectWithLocalProvenanceRepo()
+    const targetPath = path.join(projectRoot, 'jobs', 'demo', 'build-info', 'stage1.json')
+
+    await generateBuildInfoFromSourceProvenance(projectRoot)
+    const verified = await verifySourceProvenance(projectRoot)
+    expect(verified.results[0].status).toBe('verified')
+
+    const changed = JSON.parse(await fs.readFile(targetPath, 'utf-8'))
+    changed.solcVersion = '0.8.1'
+    await fs.writeFile(targetPath, JSON.stringify(changed, null, 2))
+
+    const mismatch = await verifySourceProvenance(projectRoot)
+    expect(mismatch.results[0].status).toBe('failed')
+    expect(mismatch.results[0].message).toContain('does not match')
+    expect(mismatch.results[0].message).toContain('$.solcVersion')
+  })
+
+  it('normalizes checkout-local build-info paths and top-level ids while verifying', async () => {
+    const { projectRoot } = await createProjectWithLocalProvenanceRepo({ checkoutSensitiveBuildInfo: true })
+    const targetPath = path.join(projectRoot, 'jobs', 'demo', 'build-info', 'stage1.json')
+
+    await generateBuildInfoFromSourceProvenance(projectRoot)
+    const generatedJson = JSON.parse(await fs.readFile(targetPath, 'utf-8'))
+    expect(generatedJson.id).toContain('catapult-provenance-')
+    expect(generatedJson.input.basePath).toContain('catapult-provenance-')
+
+    const verified = await verifySourceProvenance(projectRoot)
+    expect(verified.results[0].status).toBe('verified')
+  })
+
+  async function createProjectWithLocalProvenanceRepo(
+    options: { checkoutSensitiveBuildInfo?: boolean } = {}
+  ): Promise<{ projectRoot: string; expectedBuildInfo: Record<string, unknown> }> {
+    const sourceRepo = path.join(tempDir, 'source-repo')
+    const projectRoot = path.join(tempDir, 'project')
+    await fs.mkdir(sourceRepo, { recursive: true })
+
+    const expectedBuildInfo = {
+      _format: 'hh-sol-build-info-1',
+      id: 'stage1',
+      solcVersion: '0.8.0',
+      input: {
+        language: 'Solidity',
+        sources: {}
+      },
+      output: {
+        contracts: {}
+      }
+    }
+
+    const buildInfoScript = options.checkoutSensitiveBuildInfo
+      ? `
+const fs = require('fs')
+const path = require('path')
+const buildInfo = {
+  _format: 'hh-sol-build-info-1',
+  id: path.basename(path.dirname(__dirname)),
+  solcVersion: '0.8.0',
+  input: {
+    language: 'Solidity',
+    basePath: __dirname,
+    allowPaths: [__dirname, path.join(__dirname, 'lib')],
+    includePaths: [__dirname],
+    sources: {}
+  },
+  output: {
+    contracts: {}
+  }
+}
+fs.mkdirSync(path.join(__dirname, 'out', 'build-info'), { recursive: true })
+fs.writeFileSync(path.join(__dirname, 'out', 'build-info', 'stage1.json'), JSON.stringify(buildInfo, null, 2))
+`
+      : `
+const fs = require('fs')
+const path = require('path')
+fs.mkdirSync(path.join(__dirname, 'out', 'build-info'), { recursive: true })
+fs.writeFileSync(path.join(__dirname, 'out', 'build-info', 'stage1.json'), JSON.stringify(${JSON.stringify(expectedBuildInfo)}, null, 2))
+`
+
+    await writeFile(path.join(sourceRepo, 'build-info.js'), `
+${buildInfoScript.trim()}
+`)
+    await git(sourceRepo, ['init'])
+    await git(sourceRepo, ['config', 'user.email', 'catapult@example.com'])
+    await git(sourceRepo, ['config', 'user.name', 'Catapult Test'])
+    await git(sourceRepo, ['add', 'build-info.js'])
+    await git(sourceRepo, ['commit', '-m', 'add build script'])
+    const commit = await git(sourceRepo, ['rev-parse', 'HEAD'])
+
+    await writeFile(
+      path.join(projectRoot, 'jobs', 'demo', 'build-info', 'source.yaml'),
+      sourceYaml(sourceRepo, commit, 'node build-info.js')
+    )
+
+    return { projectRoot, expectedBuildInfo }
+  }
+})