@0xsequence/catapult 1.1.0

package/src/lib/parsers/__tests__/job.spec.ts

@@ -0,0 +1,335 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { parseJob } from '../job'
+import { Job } from '../../types'
+
+describe('parseJob', () => {
+  // --- Happy Path Tests ---
+
+  it('should correctly parse a valid, complex job with multiple actions and dependencies (sequence-v1)', () => {
+    const yamlPath = path.resolve(__dirname, '../../../../examples/jobs/sequence-v1.yaml')
+    const yamlContent = fs.readFileSync(yamlPath, 'utf-8')
+
+    const job: Job = parseJob(yamlContent)
+
+    expect(job.name).toBe('sequence-v1')
+    expect(job.version).toBe('1.0.0')
+    expect(job.description).toBe('The Sequence v1 contracts')
+    expect(job.depends_on).toBeUndefined()
+    expect(job.actions).toHaveLength(6)
+
+    // Spot-check a simple action
+    const factoryAction = job.actions.find((a) => a.name === 'factory')
+    expect(factoryAction).toBeDefined()
+    expect(factoryAction?.template).toBe('sequence-universal-deployer-2')
+    expect(factoryAction?.arguments).toEqual({
+      creationCode: '{{Contract(sequence/v1/factory).creationCode}}',
+      salt: '0',
+    })
+    expect(factoryAction?.depends_on).toBeUndefined()
+
+    // Spot-check an action with dependencies and complex arguments
+    const mainModuleAction = job.actions.find((a) => a.name === 'main-module')
+    expect(mainModuleAction).toBeDefined()
+    expect(mainModuleAction?.template).toBe('sequence-universal-deployer-2')
+    expect(mainModuleAction?.depends_on).toEqual(['factory'])
+    expect(mainModuleAction?.arguments).toEqual({
+      salt: '0',
+      creationCode: {
+        type: 'constructor-encode',
+        arguments: {
+          creationCode: '{{Contract(sequence/v1/main-module).creationCode}}',
+          types: ['address'],
+          values: ['{{factory.address}}'],
+        },
+      },
+    })
+  })
+
+  it('should correctly parse a job with job-level depends_on (guards-v1)', () => {
+    const yamlPath = path.resolve(__dirname, '../../../../examples/jobs/guards-v1.yaml')
+    const yamlContent = fs.readFileSync(yamlPath, 'utf-8')
+
+    const job: Job = parseJob(yamlContent)
+
+    expect(job.name).toBe('guards-v1')
+    expect(job.version).toBe('1')
+    expect(job.description).toBe('Deploy both prod and dev guards for Sequence v1')
+    expect(job.depends_on).toEqual(['sequence-v1'])
+    expect(job.actions).toHaveLength(2)
+  })
+
+  it('should handle numeric versions and convert them to strings', () => {
+    const yamlContent = `
+name: test-job
+version: 1
+description: A test job
+actions:
+  - name: action1
+    template: tpl1
+    arguments: {}
+`
+    const job = parseJob(yamlContent)
+    expect(job.version).toBe('1')
+    expect(typeof job.version).toBe('string')
+  })
+
+  // --- Error Handling and Validation Tests ---
+
+  it('should throw an error for malformed YAML', () => {
+    const invalidYaml = 'name: bad-yaml\n  actions: - item1'
+    expect(() => parseJob(invalidYaml)).toThrow(/Failed to parse job YAML:.*at line 1/)
+  })
+
+  it('should throw an error if YAML content does not resolve to an object', () => {
+    const invalidYaml = 'just-a-string'
+    expect(() => parseJob(invalidYaml)).toThrow('Invalid job: YAML content must resolve to an object.')
+  })
+
+  it('should throw an error if the "name" field is missing', () => {
+    const yamlContent = `
+version: "1.0"
+actions: []
+`
+    expect(() => parseJob(yamlContent)).toThrow('Invalid job: "name" field is required and must be a string.')
+  })
+
+  it('should throw an error if the "name" field is not a string', () => {
+    const yamlContent = `
+name: 12345
+version: "1.0"
+actions: []
+`
+    expect(() => parseJob(yamlContent)).toThrow('Invalid job: "name" field is required and must be a string.')
+  })
+
+  it('should throw an error if the "version" field is missing', () => {
+    const yamlContent = `
+name: "my-job"
+actions: []
+`
+    expect(() => parseJob(yamlContent)).toThrow('Invalid job "my-job": "version" field is required.')
+  })
+
+  it('should throw an error if the "actions" field is missing', () => {
+    const yamlContent = `
+name: "my-job"
+version: "1"
+`
+    expect(() => parseJob(yamlContent)).toThrow('Invalid job "my-job": "actions" field is required and must be an array.')
+  })
+
+  it('should throw an error if the "actions" field is not an array', () => {
+    const yamlContent = `
+name: "my-job"
+version: "1"
+actions: "not-an-array"
+`
+    expect(() => parseJob(yamlContent)).toThrow('Invalid job "my-job": "actions" field is required and must be an array.')
+  })
+
+  it('should throw an error if an item in the "actions" array is not an object', () => {
+    const yamlContent = `
+name: "my-job"
+version: "1"
+actions:
+  - "i-am-a-string-not-an-object"
+`
+    expect(() => parseJob(yamlContent)).toThrow(
+      'Invalid job "my-job": contains a non-object item in "actions" array.',
+    )
+  })
+
+  it('should throw an error if an action is missing its "name" field', () => {
+    const yamlContent = `
+name: "my-job"
+version: "1"
+actions:
+  - template: "my-template"
+    arguments: {}
+`
+    expect(() => parseJob(yamlContent)).toThrow('Invalid job "my-job": an action is missing the required "name" field.')
+  })
+
+  it('should throw an error if an action is missing its "template" field', () => {
+    const yamlContent = `
+name: "my-job"
+version: "1"
+actions:
+  - name: "my-action"
+    arguments: {}
+`
+    expect(() => parseJob(yamlContent)).toThrow(
+      'Invalid job "my-job": action "my-action" must have either a "template" field (for template actions) or a "type" field (for primitive actions).',
+    )
+  })
+
+  it('should throw an error if an action is missing its "arguments" field', () => {
+    const yamlContent = `
+name: "my-job"
+version: "1"
+actions:
+  - name: "my-action"
+    template: "my-template"
+`
+    expect(() => parseJob(yamlContent)).toThrow(
+      'Invalid job "my-job": action "my-action" is missing the required "arguments" field or it is not an object.',
+    )
+  })
+
+  it('should throw an error if an action has "arguments" that are not an object', () => {
+    const yamlContent = `
+name: "my-job"
+version: "1"
+actions:
+  - name: "my-action"
+    template: "my-template"
+    arguments: ["not", "an", "object"]
+`
+    expect(() => parseJob(yamlContent)).toThrow(
+      'Invalid job "my-job": action "my-action" is missing the required "arguments" field or it is not an object.',
+    )
+  })
+
+  // --- Output Field Tests ---
+  
+  it('should correctly parse actions with output: true', () => {
+    const yamlContent = `
+name: "my-job"
+version: "1"
+actions:
+  - name: "action-with-output"
+    template: "my-template"
+    arguments: {}
+    output: true
+`
+    const job = parseJob(yamlContent)
+    expect(job.actions[0].output).toBe(true)
+  })
+  
+  it('should correctly parse actions with output: false', () => {
+    const yamlContent = `
+name: "my-job"
+version: "1"
+actions:
+  - name: "action-without-output"
+    template: "my-template"
+    arguments: {}
+    output: false
+`
+    const job = parseJob(yamlContent)
+    expect(job.actions[0].output).toBe(false)
+  })
+  
+  it('should correctly parse actions with no output field (undefined)', () => {
+    const yamlContent = `
+name: "my-job"
+version: "1"
+actions:
+  - name: "action-no-output"
+    template: "my-template"
+    arguments: {}
+`
+    const job = parseJob(yamlContent)
+    expect(job.actions[0].output).toBeUndefined()
+  })
+
+  it('should correctly parse actions with output: object (custom map)', () => {
+    const yamlContent = `
+name: "my-job"
+version: "1"
+actions:
+  - name: "action-custom"
+    template: "my-template"
+    arguments: {}
+    output:
+      address: "{{someAddress}}"
+      txHash: "{{action-custom.hash}}"
+`
+    const job = parseJob(yamlContent)
+    expect(typeof job.actions[0].output).toBe('object')
+    expect(job.actions[0].output).toEqual({
+      address: '{{someAddress}}',
+      txHash: '{{action-custom.hash}}'
+    } as any)
+  })
+  
+  it('should throw an error if output field is not a boolean or object', () => {
+    const yamlContent = `
+name: "my-job"
+version: "1"
+actions:
+  - name: "my-action"
+    template: "my-template"
+    arguments: {}
+    output: "not-a-boolean"
+`
+    expect(() => parseJob(yamlContent)).toThrow(
+      'Invalid job "my-job": action "my-action" has an invalid "output" field. It must be either a boolean (true/false) or an object mapping custom outputs.',
+    )
+  })
+  
+  it('should throw an error if output field is a number', () => {
+    const yamlContent = `
+name: "my-job"
+version: "1"
+actions:
+  - name: "my-action"
+    template: "my-template"
+    arguments: {}
+    output: 1
+`
+    expect(() => parseJob(yamlContent)).toThrow(
+      'Invalid job "my-job": action "my-action" has an invalid "output" field. It must be either a boolean (true/false) or an object mapping custom outputs.',
+    )
+  })
+  
+  it('should correctly parse mixed actions with and without output fields', () => {
+    const yamlContent = `
+name: "my-job"
+version: "1"
+actions:
+  - name: "action1"
+    template: "template1"
+    arguments: {}
+    output: true
+  - name: "action2"
+    template: "template2"
+    arguments: {}
+  - name: "action3"
+    template: "template3"
+    arguments: {}
+    output: false
+  - name: "action4"
+    template: "template4"
+    arguments: {}
+    output:
+      important: "{{action4.hash}}"
+`
+    const job = parseJob(yamlContent)
+    expect(job.actions[0].output).toBe(true)
+    expect(job.actions[1].output).toBeUndefined()
+    expect(job.actions[2].output).toBe(false)
+    expect(job.actions[3].output).toEqual({ important: '{{action4.hash}}' } as any)
+  })
+
+  // --- New: Job-level constants field parsing ---
+
+  it('should allow an optional job-level constants block as an object', () => {
+    const yamlContent = `
+name: "job-with-constants"
+version: "1"
+constants:
+  FEE: "1000"
+  ADMIN: "0x0000000000000000000000000000000000000001"
+actions:
+  - name: "a1"
+    template: "t1"
+    arguments:
+      x: "{{FEE}}"
+`
+    const job = parseJob(yamlContent) as any
+    // parseJob doesn't attach constants; loader attaches it. This test ensures YAML is acceptable and does not throw.
+    expect(job.name).toBe('job-with-constants')
+  })
+})

package/src/lib/parsers/__tests__/template.spec.ts

@@ -0,0 +1,111 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { parseTemplate } from '../template'
+import { isContractExistsCondition, isJobCompletedCondition, Template } from '../../types'
+
+describe('parseTemplate', () => {
+  // --- Happy Path Tests ---
+
+  it('should correctly parse a valid template with a complex structure (sequence-factory-v1)', () => {
+    const yamlPath = path.resolve(__dirname, '../../../../examples/templates/sequence-factory-v1.yaml')
+    const yamlContent = fs.readFileSync(yamlPath, 'utf-8')
+
+    const template = parseTemplate(yamlContent)
+
+    expect(template.name).toBe('sequence-factory-v1')
+    expect(template.arguments).toBeDefined()
+    expect(template.returns).toBeDefined()
+    expect(template.actions).toHaveLength(1)
+    expect(template.outputs).toBeDefined()
+    expect(template.outputs?.address).toBeDefined()
+
+    // Test the specific 'setup' block parsing where it's an array of conditions
+    expect(template.setup).toBeDefined()
+    expect(template.setup?.actions).toBeUndefined() // No actions in this setup
+    expect(template.setup?.skip_condition).toHaveLength(1)
+    expect(isJobCompletedCondition(template.setup?.skip_condition?.[0])).toBe(true)
+  })
+
+  it('should correctly parse a template with an object-based setup block (nano-universal-deployer)', () => {
+    const yamlPath = path.resolve(__dirname, '../../std/templates/nano-universal-deployer.yaml')
+    const yamlContent = fs.readFileSync(yamlPath, 'utf-8')
+
+    const template = parseTemplate(yamlContent)
+
+    expect(template.name).toBe('nano-universal-deployer')
+
+    // Test the specific 'setup' block parsing where it's a structured object
+    expect(template.setup).toBeDefined()
+    expect(template.setup?.actions).toHaveLength(3)
+    expect(template.setup?.skip_condition).toHaveLength(1)
+    expect(template.setup?.actions?.[0].type).toBe('test-nicks-method')
+    expect(isContractExistsCondition(template.setup?.skip_condition?.[0])).toBe(true)
+  })
+
+  it('should parse a template with no optional fields like setup, description, arguments, or outputs', () => {
+    const minimalYaml = `
+name: minimal-template
+actions:
+  - type: send-transaction
+    arguments:
+      to: '0x123'
+      data: '0xabc'
+`
+    const template = parseTemplate(minimalYaml)
+    expect(template.name).toBe('minimal-template')
+    expect(template.description).toBeUndefined()
+    expect(template.arguments).toBeUndefined()
+    expect(template.setup).toBeUndefined()
+    expect(template.actions).toHaveLength(1)
+    expect(template.outputs).toBeUndefined()
+  })
+
+  // --- Error Handling and Validation Tests ---
+
+  it('should throw an error for malformed YAML', () => {
+    const invalidYaml = `
+name: bad-yaml
+  actions: - item1
+`
+    expect(() => parseTemplate(invalidYaml)).toThrow(/Failed to parse template YAML:.* at line 2/)
+  })
+
+  it('should throw an error if the "name" field is missing', () => {
+    const yamlContent = `
+version: "1.0"
+actions: []
+`
+    expect(() => parseTemplate(yamlContent)).toThrow('Invalid template: "name" field is required and must be a string.')
+  })
+
+  it('should throw an error if the "actions" field is missing or not an array', () => {
+    const missingActions = `
+name: "my-template"
+`
+    expect(() => parseTemplate(missingActions)).toThrow('Invalid template "my-template": "actions" field is required and must be an array.')
+
+    const wrongTypeActions = `
+name: "my-template"
+actions: "not-an-array"
+`
+    expect(() => parseTemplate(wrongTypeActions)).toThrow('Invalid template "my-template": "actions" field is required and must be an array.')
+  })
+
+  it('should throw an error if the "outputs" field is not an object when provided', () => {
+    const wrongTypeOutputs = `
+name: "my-template"
+actions: []
+outputs: ["not-an-object"]
+`
+    expect(() => parseTemplate(wrongTypeOutputs)).toThrow('Invalid template "my-template": "outputs" field must be an object if provided.')
+  })
+
+  it('should throw an error if the "setup" field is not an array or object', () => {
+    const invalidSetup = `
+name: "my-template"
+actions: []
+setup: "i-am-a-string"
+`
+    expect(() => parseTemplate(invalidSetup)).toThrow('Invalid template "my-template": "setup" field must be an array or an object if provided.')
+  })
+})

package/src/lib/parsers/artifact/__tests__/artifact.spec.ts

@@ -0,0 +1,117 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { parseArtifact } from '../index'
+
+describe('Artifact Parsing', () => {
+  const fixturesDir = path.join(__dirname, 'fixtures')
+
+  // Helper function to read fixture files
+  const readFixture = (filename: string): string => {
+    return fs.readFileSync(path.join(fixturesDir, filename), 'utf-8')
+  }
+
+  describe('parseArtifact function', () => {
+    it('should parse a simple artifact with string bytecode', () => {
+      const content = readFixture('simple-artifact.json')
+      const result = parseArtifact(content, '/test/simple-artifact.json')
+
+      expect(result).not.toBeNull()
+      expect(result!.contractName).toBe('SimpleToken')
+      expect(result!.abi).toBeInstanceOf(Array)
+      expect(result!.abi.length).toBe(2)
+      expect(result!.bytecode).toMatch(/^0x[0-9a-fA-F]+$/)
+      expect(result!.deployedBytecode).toMatch(/^0x[0-9a-fA-F]+$/)
+    })
+
+    it('should parse a Hardhat-style artifact with bytecode object', () => {
+      const content = readFixture('hardhat-artifact.json')
+      const result = parseArtifact(content, '/test/hardhat-artifact.json')
+
+      expect(result).not.toBeNull()
+      expect(result!.contractName).toBe('ERC20Token')
+      expect(result!.sourceName).toBe('contracts/ERC20Token.sol')
+      expect(result!.abi).toBeInstanceOf(Array)
+      expect(result!.abi.length).toBe(3)
+      expect(result!.bytecode).toMatch(/^0x[0-9a-fA-F]+$/)
+      expect(result!.deployedBytecode).toMatch(/^0x[0-9a-fA-F]+$/)
+      expect(result!.compiler).toBeDefined()
+      expect(result!.compiler!.version).toBe('0.8.19+commit.7dd6d404')
+      expect(result!.source).toContain('contract ERC20Token')
+    })
+
+    it('should parse a minimal artifact with only required fields', () => {
+      const content = readFixture('minimal-artifact.json')
+      const result = parseArtifact(content, '/test/minimal-artifact.json')
+
+      expect(result).not.toBeNull()
+      expect(result!.contractName).toBe('Minimal')
+      expect(result!.abi).toBeInstanceOf(Array)
+      expect(result!.abi.length).toBe(0)
+      expect(result!.bytecode).toBe('0x608060405234801561001057600080fd5b50')
+      expect(result!.deployedBytecode).toBeUndefined()
+      expect(result!.sourceName).toBeUndefined()
+      expect(result!.source).toBeUndefined()
+      expect(result!.compiler).toBeUndefined()
+    })
+
+    it('should return null for invalid JSON', () => {
+      const content = readFixture('invalid-json.txt')
+      const result = parseArtifact(content, '/test/invalid-json.txt')
+
+      expect(result).toBeNull()
+    })
+
+    it('should derive contractName from filename when missing', () => {
+      const content = readFixture('missing-contract-name.json')
+      const result = parseArtifact(content, '/test/missing-contract-name.json')
+
+      expect(result).not.toBeNull()
+      expect(result!.contractName).toBe('missing-contract-name')
+    })
+
+    it('should return null when abi is missing', () => {
+      const content = readFixture('missing-abi.json')
+      const result = parseArtifact(content, '/test/missing-abi.json')
+
+      expect(result).toBeNull()
+    })
+
+    it('should return null when bytecode is missing', () => {
+      const content = readFixture('missing-bytecode.json')
+      const result = parseArtifact(content, '/test/missing-bytecode.json')
+
+      expect(result).toBeNull()
+    })
+
+    it('should return null when bytecode does not start with 0x', () => {
+      const content = readFixture('invalid-bytecode.json')
+      const result = parseArtifact(content, '/test/invalid-bytecode.json')
+
+      expect(result).toBeNull()
+    })
+
+    it('should return null when bytecode is empty', () => {
+      const content = readFixture('empty-bytecode.json')
+      const result = parseArtifact(content, '/test/empty-bytecode.json')
+
+      expect(result).toBeNull()
+    })
+
+    it('should return null when fields have wrong types', () => {
+      const content = readFixture('wrong-types.json')
+      const result = parseArtifact(content, '/test/wrong-types.json')
+
+      expect(result).toBeNull()
+    })
+
+    it('should handle null input gracefully', () => {
+      const result = parseArtifact('null', '/test/null.json')
+      expect(result).toBeNull()
+    })
+
+    it('should handle empty string input gracefully', () => {
+      const result = parseArtifact('', '/test/empty.json')
+      expect(result).toBeNull()
+    })
+  })
+}) 

package/src/lib/parsers/artifact/__tests__/fixtures/empty-bytecode.json

@@ -0,0 +1,5 @@
+{
+  "contractName": "EmptyBytecode",
+  "abi": [],
+  "bytecode": ""
+} 

package/src/lib/parsers/artifact/__tests__/fixtures/hardhat-artifact.json

@@ -0,0 +1,67 @@
+{
+  "contractName": "ERC20Token",
+  "sourceName": "contracts/ERC20Token.sol",
+  "abi": [
+    {
+      "type": "constructor",
+      "inputs": [
+        {
+          "name": "initialSupply",
+          "type": "uint256"
+        }
+      ]
+    },
+    {
+      "type": "function",
+      "name": "balanceOf",
+      "inputs": [
+        {
+          "name": "account",
+          "type": "address"
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view"
+    },
+    {
+      "type": "event",
+      "name": "Transfer",
+      "inputs": [
+        {
+          "name": "from",
+          "type": "address",
+          "indexed": true
+        },
+        {
+          "name": "to", 
+          "type": "address",
+          "indexed": true
+        },
+        {
+          "name": "value",
+          "type": "uint256",
+          "indexed": false
+        }
+      ]
+    }
+  ],
+  "bytecode": {
+    "object": "0x608060405234801561001057600080fd5b50604051610abc380380610abc8339818101604052810190610032919061007a565b806000819055505061009e565b600080fd5b6000819050919050565b61005681610043565b811461006157600080fd5b50565b6000815190506100738161004d565b92915050565b60006020828403121561008f5761008e61003e565b5b600061009d84828501610064565b91505092915050565b610a0f806100ad6000396000f3fe608060405234801561001057600080fd5b50600436106100575760003560e01c806318160ddd1461005c57806370a0823114610078578063a9059cbb146100a8578063dd62ed3e146100c4575b600080fd5b6100646100f4565b60405161006f919061018a565b60405180910390f35b610092600480360381019061008d91906101d6565b6100fa565b60405161009f919061018a565b60405180910390f35b6100c260048036038101906100bd919061024f565b610142565b005b6100de60048036038101906100d9919061028f565b61015c565b6040516100eb919061018a565b60405180910390f35b60005481565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b600061014f338484610181565b905092915050565b5050565b600060016000858573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050929150505600a2646970667358221220",
+    "sourceMap": "123:456:0:-:0;;;789:100;;;;;;;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;;:::i;:::-;;:::o;8:123:-1;5:3;2:1;21:10;18:1;14:2;11:3;8:2;123:456:0;;;;;;;",
+    "linkReferences": {}
+  },
+  "deployedBytecode": {
+    "object": "0x608060405234801561001057600080fd5b50600436106100575760003560e01c806318160ddd1461005c57806370a0823114610078578063a9059cbb146100a8578063dd62ed3e146100c4575b600080fd5b6100646100f4565b60405161006f919061018a565b60405180910390f35b610092600480360381019061008d91906101d6565b6100fa565b60405161009f919061018a565b60405180910390f35b6100c260048036038101906100bd919061024f565b610142565b005b6100de60048036038101906100d9919061028f565b61015c565b6040516100eb919061018a565b60405180910390f35b60005481565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b600061014f338484610181565b905092915050565b5050565b600060016000858573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050929150505600a2646970667358221220",
+    "sourceMap": "123:456:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;;:::i;:::-;;:::o;",
+    "linkReferences": {}
+  },
+  "compiler": {
+    "version": "0.8.19+commit.7dd6d404"
+  },
+  "source": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract ERC20Token {\n    mapping(address => uint256) private _balances;\n    mapping(address => mapping(address => uint256)) private _allowances;\n    uint256 private _totalSupply;\n    \n    constructor(uint256 initialSupply) {\n        _totalSupply = initialSupply;\n        _balances[msg.sender] = initialSupply;\n    }\n    \n    function balanceOf(address account) public view returns (uint256) {\n        return _balances[account];\n    }\n}\n"
+} 

package/src/lib/parsers/artifact/__tests__/fixtures/invalid-bytecode.json

@@ -0,0 +1,5 @@
+{
+  "contractName": "InvalidBytecode",
+  "abi": [],
+  "bytecode": "608060405234801561001057600080fd5b50"
+} 

package/src/lib/parsers/artifact/__tests__/fixtures/invalid-json.txt

@@ -0,0 +1,11 @@
+{
+  "contractName": "InvalidJson",
+  "abi": [
+    {
+      "type": "function"
+      // Missing comma here makes it invalid JSON
+      "name": "test"
+    }
+  ]
+  "bytecode": "0x123"
+} 

package/src/lib/parsers/artifact/__tests__/fixtures/minimal-artifact.json

@@ -0,0 +1,5 @@
+{
+  "contractName": "Minimal",
+  "abi": [],
+  "bytecode": "0x608060405234801561001057600080fd5b50"
+} 

package/src/lib/parsers/artifact/__tests__/fixtures/missing-abi.json

@@ -0,0 +1,4 @@
+{
+  "contractName": "MissingAbi",
+  "bytecode": "0x608060405234801561001057600080fd5b50"
+} 

package/src/lib/parsers/artifact/__tests__/fixtures/missing-bytecode.json

@@ -0,0 +1,11 @@
+{
+  "contractName": "MissingBytecode",
+  "abi": [
+    {
+      "type": "function",
+      "name": "test",
+      "inputs": [],
+      "outputs": []
+    }
+  ]
+}