@0xsequence/catapult 1.4.0 → 1.5.0

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

@@ -1,150 +0,0 @@
-import * as fs from 'fs/promises'
-import * as path from 'path'
-import { loadNetworks } from '../network-loader'
-
-const tmpDir = path.join(process.cwd(), '.tmp-network-loader-tests')
-
-async function writeNetworksYaml(projectRoot: string, yamlContent: string): Promise<void> {
-  await fs.mkdir(projectRoot, { recursive: true })
-  await fs.writeFile(path.join(projectRoot, 'networks.yaml'), yamlContent, 'utf-8')
-}
-
-describe('network-loader rpcUrl token replacement', () => {
-  const originalEnv = { ...process.env }
-
-  beforeAll(async () => {
-    await fs.mkdir(tmpDir, { recursive: true })
-  })
-
-  afterEach(() => {
-    process.env = { ...originalEnv }
-  })
-
-  afterAll(async () => {
-    try {
-      await fs.rm(tmpDir, { recursive: true, force: true })
-    } catch {}
-  })
-
-  test('replaces {{RPC_*}} tokens with env values', async () => {
-    const projectRoot = path.join(tmpDir, 'case1')
-    process.env.RPC_URL_TOKEN = 'abc123'
-    const yaml = `
-- name: "TestNet"
-  chainId: 123
-  rpcUrl: "https://node.example.com/{{RPC_URL_TOKEN}}"
-`
-    await writeNetworksYaml(projectRoot, yaml)
-
-    const networks = await loadNetworks(projectRoot)
-    expect(networks).toHaveLength(1)
-    expect(networks[0].rpcUrl).toBe('https://node.example.com/abc123')
-  })
-
-  test('leaves non-RPC tokens intact', async () => {
-    const projectRoot = path.join(tmpDir, 'case2')
-    process.env.SOME_TOKEN = 'should_not_be_used'
-    const yaml = `
-- name: "TestNet"
-  chainId: 123
-  rpcUrl: "https://node.example.com/{{SOME_TOKEN}}"
-`
-    await writeNetworksYaml(projectRoot, yaml)
-
-    const networks = await loadNetworks(projectRoot)
-    expect(networks[0].rpcUrl).toBe('https://node.example.com/{{SOME_TOKEN}}')
-  })
-
-  test('supports multiple RPC tokens in a single url', async () => {
-    const projectRoot = path.join(tmpDir, 'case3')
-    process.env.RPC_A = 'A'
-    process.env.RPC_B = 'B'
-    const yaml = `
-- name: "TestNet"
-  chainId: 123
-  rpcUrl: "https://node.example.com/{{RPC_A}}/path/{{RPC_B}}"
-`
-    await writeNetworksYaml(projectRoot, yaml)
-
-    const networks = await loadNetworks(projectRoot)
-    expect(networks[0].rpcUrl).toBe('https://node.example.com/A/path/B')
-  })
-
-  test('trims whitespace within tokens', async () => {
-    const projectRoot = path.join(tmpDir, 'case4')
-    process.env.RPC_TOKEN = 'XYZ'
-    const yaml = `
-- name: "TestNet"
-  chainId: 123
-  rpcUrl: "https://node.example.com/{{  RPC_TOKEN   }}"
-`
-    await writeNetworksYaml(projectRoot, yaml)
-
-    const networks = await loadNetworks(projectRoot)
-    expect(networks[0].rpcUrl).toBe('https://node.example.com/XYZ')
-  })
-
-  test('defaults to empty string when RPC token has no matching env var', async () => {
-    const projectRoot = path.join(tmpDir, 'case5')
-    delete process.env.RPC_MISSING
-    const yaml = `
-- name: "TestNet"
-  chainId: 123
-  rpcUrl: "https://node.example.com/{{RPC_MISSING}}"
-`
-    await writeNetworksYaml(projectRoot, yaml)
-
-    const networks = await loadNetworks(projectRoot)
-    expect(networks[0].rpcUrl).toBe('https://node.example.com/')
-  })
-})
-
-describe('network-loader params', () => {
-  afterAll(async () => {
-    try {
-      await fs.rm(tmpDir, { recursive: true, force: true })
-    } catch {}
-  })
-
-  test('passes through valid params object', async () => {
-    const projectRoot = path.join(tmpDir, 'params-valid')
-    const yaml = `
-- name: "MyNet"
-  chainId: 4217
-  rpcUrl: "http://127.0.0.1:8545"
-  params:
-    myParam: true
-`
-    await writeNetworksYaml(projectRoot, yaml)
-
-    const networks = await loadNetworks(projectRoot)
-    expect(networks).toHaveLength(1)
-    expect(networks[0].params).toEqual({ myParam: true })
-  })
-
-  test('rejects params when not a plain object', async () => {
-    const projectRoot = path.join(tmpDir, 'params-invalid-array')
-    const yaml = `
-- name: "BadNet"
-  chainId: 1
-  rpcUrl: "http://127.0.0.1:8545"
-  params: [1, 2, 3]
-`
-    await writeNetworksYaml(projectRoot, yaml)
-
-    await expect(loadNetworks(projectRoot)).rejects.toThrow(/Failed to load or parse networks.yaml/)
-  })
-
-  test('rejects params when null', async () => {
-    const projectRoot = path.join(tmpDir, 'params-invalid-null')
-    const yaml = `
-- name: "BadNet"
-  chainId: 1
-  rpcUrl: "http://127.0.0.1:8545"
-  params: null
-`
-    await writeNetworksYaml(projectRoot, yaml)
-
-    await expect(loadNetworks(projectRoot)).rejects.toThrow(/Failed to load or parse networks.yaml/)
-  })
-})

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

@@ -1,41 +0,0 @@
-import { resolveSelectedChainIds, resolveSingleChainId } from '../../lib/network-selection'
-import { Network } from '../../lib/types'
-
-describe('network-selection', () => {
-  const networks: Network[] = [
-    { name: 'Mainnet', chainId: 1, rpcUrl: 'https://mainnet' },
-    { name: 'Arbitrum One', chainId: 42161, rpcUrl: 'https://arb' },
-    { name: 'Polygon', chainId: 137, rpcUrl: 'https://polygon' },
-    { name: 'Mainnet', chainId: 10_000, rpcUrl: 'https://fork' },
-  ]
-
-  it('returns undefined for empty/undefined input', () => {
-    expect(resolveSelectedChainIds(undefined, networks)).toBeUndefined()
-    expect(resolveSelectedChainIds('', networks)).toBeUndefined()
-    expect(resolveSelectedChainIds('   ', networks)).toBeUndefined()
-  })
-
-  it('parses numeric IDs and removes duplicates', () => {
-    expect(resolveSelectedChainIds('1,1,42161', networks)).toEqual([1, 42161])
-  })
-
-  it('matches names case-insensitively and includes all with same name', () => {
-    expect(resolveSelectedChainIds('mainnet', networks)).toEqual([1, 10000])
-    expect(resolveSelectedChainIds('MAINNET,polygon', networks)).toEqual([1, 10000, 137])
-  })
-
-  it('preserves token order and then network order for name matches', () => {
-    expect(resolveSelectedChainIds('polygon,mainnet', networks)).toEqual([137, 1, 10000])
-  })
-
-  it('throws on unknown name', () => {
-    expect(() => resolveSelectedChainIds('unknown', networks)).toThrow(/Unknown network selector/)
-  })
-
-  it('resolveSingleChainId returns first match for name and first token for multi', () => {
-    expect(resolveSingleChainId('mainnet', networks)).toBe(1)
-    expect(resolveSingleChainId('137,1', networks)).toBe(137)
-  })
-})
-
-

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

@@ -1,230 +0,0 @@
-import { detectNetworkFromRpc, isValidRpcUrl } from '../network-utils'
-import { Network } from '../types'
-
-// Mock ethers.JsonRpcProvider
-jest.mock('ethers', () => ({
-  ...jest.requireActual('ethers'),
-  ethers: {
-    ...jest.requireActual('ethers').ethers,
-    JsonRpcProvider: jest.fn().mockImplementation(() => ({
-      getNetwork: jest.fn()
-    }))
-  }
-}))
-
-describe('Network Utils', () => {
-  describe('isValidRpcUrl', () => {
-    it('should validate valid HTTP RPC URLs', () => {
-      expect(isValidRpcUrl('http://localhost:8545')).toBe(true)
-      expect(isValidRpcUrl('https://mainnet.infura.io/v3/abc123')).toBe(true)
-    })
-
-    it('should validate valid WebSocket RPC URLs', () => {
-      expect(isValidRpcUrl('ws://localhost:8545')).toBe(true)
-      expect(isValidRpcUrl('wss://mainnet.infura.io/v3/abc123')).toBe(true)
-    })
-
-    it('should reject invalid URLs', () => {
-      expect(isValidRpcUrl('invalid-url')).toBe(false)
-      expect(isValidRpcUrl('ftp://example.com')).toBe(false)
-      expect(isValidRpcUrl('')).toBe(false)
-    })
-
-    it('should reject URLs without hostname', () => {
-      expect(isValidRpcUrl('http://')).toBe(false)
-    })
-  })
-
-  describe('detectNetworkFromRpc', () => {
-    let mockGetNetwork: jest.Mock
-
-    beforeEach(() => {
-      // Reset mocks
-      jest.clearAllMocks()
-      
-      // Mock the JsonRpcProvider constructor and getNetwork method
-      const { ethers } = require('ethers')
-      mockGetNetwork = jest.fn()
-      
-      // Mock the provider's getNetwork method
-      ethers.JsonRpcProvider.mockImplementation(() => ({
-        getNetwork: mockGetNetwork
-      }))
-    })
-
-    it('should detect network successfully', async () => {
-      const mockNetwork = {
-        name: 'mainnet',
-        chainId: 1
-      }
-      
-      mockGetNetwork.mockResolvedValue(mockNetwork)
-
-      const result = await detectNetworkFromRpc('https://mainnet.infura.io/v3/abc123')
-
-      expect(result).toEqual({
-        name: 'mainnet',
-        chainId: 1,
-        rpcUrl: 'https://mainnet.infura.io/v3/abc123'
-      })
-
-      // Verify provider was created with correct URL
-      const { ethers } = require('ethers')
-      expect(ethers.JsonRpcProvider).toHaveBeenCalledWith('https://mainnet.infura.io/v3/abc123')
-    })
-
-    it('should handle network with unknown name', async () => {
-      const mockNetwork = {
-        name: 'unknown',
-        chainId: 31337
-      }
-      
-      mockGetNetwork.mockResolvedValue(mockNetwork)
-
-      const result = await detectNetworkFromRpc('http://localhost:8545')
-
-      expect(result).toEqual({
-        name: 'unknown',
-        chainId: 31337,
-        rpcUrl: 'http://localhost:8545'
-      })
-    })
-
-    it('should handle connection errors', async () => {
-      mockGetNetwork.mockRejectedValue(new Error('Connection failed'))
-
-      await expect(detectNetworkFromRpc('http://localhost:8545'))
-        .rejects.toThrow('Failed to detect network from RPC URL "http://localhost:8545": Connection failed')
-    })
-
-    it('should handle network detection errors', async () => {
-      mockGetNetwork.mockRejectedValue(new Error('Network not supported'))
-
-      await expect(detectNetworkFromRpc('http://invalid-rpc.com'))
-        .rejects.toThrow('Failed to detect network from RPC URL "http://invalid-rpc.com": Network not supported')
-    })
-  })
-
-  describe('Integration with Run Command', () => {
-    it('should create a complete Network object from detected information', async () => {
-      const { ethers } = require('ethers')
-
-      const mockNetwork = {
-        name: 'sepolia',
-        chainId: 11155111,
-      }
-
-      const getNetworkMock = jest.fn().mockResolvedValue(mockNetwork)
-      ethers.JsonRpcProvider.mockImplementation(() => ({
-        getNetwork: getNetworkMock,
-      }))
-
-      const detectedInfo = await detectNetworkFromRpc('https://sepolia.infura.io/v3/abc123')
-
-      // Simulate what the run command does
-      const customNetwork: Network = {
-        name: detectedInfo.name || `custom-${detectedInfo.chainId}`,
-        chainId: detectedInfo.chainId!,
-        rpcUrl: 'https://sepolia.infura.io/v3/abc123',
-        supports: detectedInfo.supports || [],
-        gasLimit: detectedInfo.gasLimit,
-        testnet: detectedInfo.testnet,
-        evmVersion: detectedInfo.evmVersion,
-        params: detectedInfo.params,
-      }
-
-      expect(customNetwork).toEqual({
-        name: 'sepolia',
-        chainId: 11155111,
-        rpcUrl: 'https://sepolia.infura.io/v3/abc123',
-        supports: [],
-        gasLimit: 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')
-
-      const mockNetwork = {
-        name: 'unknown',
-        chainId: 42,
-      }
-
-      const getNetworkMock = jest.fn().mockResolvedValue(mockNetwork)
-      ethers.JsonRpcProvider.mockImplementation(() => ({
-        getNetwork: getNetworkMock,
-      }))
-
-      const detectedInfo = await detectNetworkFromRpc('http://custom-network:8545')
-
-      // Simulate what the run command does
-      const customNetwork: Network = {
-        name: detectedInfo.name || `custom-${detectedInfo.chainId}`,
-        chainId: detectedInfo.chainId!,
-        rpcUrl: 'http://custom-network:8545',
-        supports: detectedInfo.supports || [],
-        gasLimit: detectedInfo.gasLimit,
-        testnet: detectedInfo.testnet,
-        evmVersion: detectedInfo.evmVersion,
-        params: detectedInfo.params,
-      }
-
-      expect(customNetwork).toEqual({
-        name: 'unknown',
-        chainId: 42,
-        rpcUrl: 'http://custom-network:8545',
-        supports: [],
-        gasLimit: undefined,
-        testnet: undefined,
-        evmVersion: undefined,
-        params: undefined,
-      })
-    })
-  })
-})

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

@@ -1,208 +0,0 @@
-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 }
-  }
-})

package/src/lib/artifacts/__tests__/fixtures/contract1.json

@@ -1,19 +0,0 @@
-{
-  "contractName": "TestContract1",
-  "sourceName": "contracts/TestContract1.sol",
-  "abi": [
-    {
-      "type": "function",
-      "name": "getValue",
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "",
-          "type": "uint256"
-        }
-      ]
-    }
-  ],
-  "bytecode": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806320965255146100365780636d4ce63c14610040575b600080fd5b610040610058565b005b610048610062565b6040516100579190610078565b60405180910390f35b0000005b6000806000fefe",
-  "deployedBytecode": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806320965255146100365780636d4ce63c14610040575b600080fd5b610040610058565b005b610048610062565b6040516100579190610078565b60405180910390f35b6000fefe"
-} 

package/src/lib/artifacts/__tests__/fixtures/contract2.json

@@ -1,19 +0,0 @@
-{
-  "contractName": "TestContract2",
-  "sourceName": "contracts/TestContract2.sol",
-  "abi": [
-    {
-      "type": "function",
-      "name": "setValue",
-      "inputs": [
-        {
-          "name": "value",
-          "type": "uint256"
-        }
-      ],
-      "outputs": []
-    }
-  ],
-  "bytecode": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806355241077146100365780636d4ce63c14610040575b600080fd5b610040610058565b005b610048610062565b6040516100579190610078565b60405180910390f35b6000fefe",
-  "deployedBytecode": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806355241077146100365780636d4ce63c14610040575b600080fd5b610040610058565b005b610048610062565b6040516100579190610078565b60405180910390f35b6000fefe"
-} 

package/src/lib/artifacts/__tests__/fixtures/duplicate-name.json

@@ -1,19 +0,0 @@
-{
-  "contractName": "TestContract1",
-  "sourceName": "contracts/DuplicateTestContract1.sol",
-  "abi": [
-    {
-      "type": "function",
-      "name": "differentFunction",
-      "inputs": [],
-      "outputs": [
-        {
-          "name": "",
-          "type": "string"
-        }
-      ]
-    }
-  ],
-  "bytecode": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806320965255146100365780636d4ce63c14610040575b600080fd5b610040610058565b005b610048610062565b6040516100579190610078565b60405180910390f35b0000005b6000806000fefe",
-  "deployedBytecode": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806320965255146100365780636d4ce63c14610040575b600080fd5b610040610058565b005b610048610062565b6040516100579190610078565b60405180910390f35b6000fefe"
-}