@0xsequence/catapult 1.3.17 → 1.5.0

package/src/lib/contracts/__tests__/repository.spec.ts

@@ -1,344 +0,0 @@
-import * as fs from 'fs/promises'
-import * as path from 'path'
-import { ContractRepository } from '../repository'
-import { Contract } from '../../types/contracts'
-
-describe('ContractRepository', () => {
-  let repository: ContractRepository
-  let tempDir: string
-
-  beforeEach(async () => {
-    repository = new ContractRepository()
-    
-    // Create a temporary directory for test files
-    tempDir = path.join(__dirname, 'temp-test-files')
-    await fs.mkdir(tempDir, { recursive: true })
-  })
-
-  afterEach(async () => {
-    // Clean up temporary files
-    try {
-      await fs.rm(tempDir, { recursive: true, force: true })
-    } catch (error) {
-      // Ignore cleanup errors
-    }
-  })
-
-  describe('loadFrom method', () => {
-    it('should find and load standard artifact files', async () => {
-      const artifactContent = JSON.stringify({
-        contractName: 'TestContract',
-        abi: [{ type: 'function', name: 'test' }],
-        bytecode: '0x608060405234801561001057600080fd5b50',
-        deployedBytecode: '0x608060405234801561001057600080fd5b506004361061003957600080fd5b50'
-      })
-
-      const artifactPath = path.join(tempDir, 'TestContract.json')
-      await fs.writeFile(artifactPath, artifactContent)
-
-      await repository.loadFrom(tempDir)
-
-      const contracts = repository.getAll()
-      expect(contracts).toHaveLength(1)
-
-      const contract = contracts[0]
-      expect(contract.contractName).toBe('TestContract')
-      expect(contract.creationCode).toBe('0x608060405234801561001057600080fd5b50')
-      expect(contract.runtimeBytecode).toBe('0x608060405234801561001057600080fd5b506004361061003957600080fd5b50')
-      expect(contract.abi).toEqual([{ type: 'function', name: 'test' }])
-      expect(contract._sources.has(artifactPath)).toBe(true)
-    })
-
-    it('should find and load build-info files', async () => {
-      const buildInfoContent = JSON.stringify({
-        _format: 'hh-sol-build-info-1',
-        id: 'test-build-id',
-        solcVersion: '0.8.0',
-        solcLongVersion: '0.8.0+commit.c7dfd78e',
-        input: {
-          language: 'Solidity',
-          sources: {
-            'src/TestContract.sol': {
-              content: 'contract TestContract { function test() public {} }'
-            }
-          },
-          settings: {
-            outputSelection: {
-              '*': {
-                '*': ['abi', 'evm.bytecode', 'evm.deployedBytecode']
-              }
-            }
-          }
-        },
-        output: {
-          contracts: {
-            'src/TestContract.sol': {
-              TestContract: {
-                abi: [{ type: 'function', name: 'test' }],
-                evm: {
-                  bytecode: {
-                    object: '0x608060405234801561001057600080fd5b50'
-                  },
-                  deployedBytecode: {
-                    object: '0x608060405234801561001057600080fd5b506004361061003939600080fd5b50'
-                  }
-                }
-              }
-            }
-          },
-          sources: {}
-        }
-      })
-
-      const buildInfoDir = path.join(tempDir, 'build-info')
-      await fs.mkdir(buildInfoDir, { recursive: true })
-      const buildInfoPath = path.join(buildInfoDir, 'test-buildinfo.json')
-      await fs.writeFile(buildInfoPath, buildInfoContent)
-
-      await repository.loadFrom(tempDir)
-
-      const contracts = repository.getAll()
-      expect(contracts).toHaveLength(1)
-
-      const contract = contracts[0]
-      expect(contract.contractName).toBe('TestContract')
-      expect(contract.sourceName).toBe('src/TestContract.sol')
-      expect(contract.creationCode).toBe('0x608060405234801561001057600080fd5b50')
-      expect(contract.runtimeBytecode).toBe('0x608060405234801561001057600080fd5b506004361061003939600080fd5b50')
-      expect(contract.abi).toEqual([{ type: 'function', name: 'test' }])
-      expect(contract.buildInfoId).toBe('test-build-id')
-      expect(contract.source).toBe('contract TestContract { function test() public {} }')
-      expect(contract._sources.has(buildInfoPath)).toBe(true)
-    })
-
-    it('should hydrate contracts from multiple source files', async () => {
-      // Create a basic artifact file (minimal info, will be hydrated by build-info)
-      const artifactContent = JSON.stringify({
-        contractName: 'TestContract',
-        abi: [],
-        bytecode: '0x608060405234801561001057600080fd5b50'
-      })
-      const artifactPath = path.join(tempDir, 'TestContract.json')
-      await fs.writeFile(artifactPath, artifactContent)
-
-      // Create a build-info file with the same bytecode but more complete information
-      const buildInfoContent = JSON.stringify({
-        _format: 'hh-sol-build-info-1',
-        id: 'test-build-id',
-        solcVersion: '0.8.0',
-        solcLongVersion: '0.8.0+commit.c7dfd78e',
-        input: {
-          language: 'Solidity',
-          sources: {
-            'src/TestContract.sol': {
-              content: 'contract TestContract { function test() public {} }'
-            }
-          },
-          settings: {
-            outputSelection: {
-              '*': {
-                '*': ['abi', 'evm.bytecode', 'evm.deployedBytecode']
-              }
-            }
-          }
-        },
-        output: {
-          contracts: {
-            'src/TestContract.sol': {
-              TestContract: {
-                abi: [{ type: 'function', name: 'test' }],
-                evm: {
-                  bytecode: {
-                    object: '0x608060405234801561001057600080fd5b50'
-                  },
-                  deployedBytecode: {
-                    object: '0x608060405234801561001057600080fd5b506004361061003939600080fd5b50'
-                  }
-                }
-              }
-            }
-          },
-          sources: {}
-        }
-      })
-
-      const buildInfoDir = path.join(tempDir, 'build-info')
-      await fs.mkdir(buildInfoDir, { recursive: true })
-      const buildInfoPath = path.join(buildInfoDir, 'test-buildinfo.json')
-      await fs.writeFile(buildInfoPath, buildInfoContent)
-
-      await repository.loadFrom(tempDir)
-
-      const contracts = repository.getAll()
-      expect(contracts).toHaveLength(1)
-
-      const contract = contracts[0]
-      // Should have information from both sources
-      expect(contract.contractName).toBe('TestContract')
-      expect(contract.sourceName).toBe('src/TestContract.sol')
-      expect(contract.abi).toEqual([{ type: 'function', name: 'test' }])
-      expect(contract.buildInfoId).toBe('test-build-id')
-      expect(contract.source).toBe('contract TestContract { function test() public {} }')
-      expect(contract._sources.has(artifactPath)).toBe(true)
-      expect(contract._sources.has(buildInfoPath)).toBe(true)
-    })
-  })
-
-  describe('disambiguateReferences method', () => {
-    beforeEach(async () => {
-      // Create test files with deliberate name collisions
-      const artifact1Content = JSON.stringify({
-        contractName: 'MyToken',
-        abi: [],
-        bytecode: '0x608060405234801561001057600080fd5b50111111'
-      })
-      const artifact1Path = path.join(tempDir, 'contracts', 'MyToken.json')
-      await fs.mkdir(path.dirname(artifact1Path), { recursive: true })
-      await fs.writeFile(artifact1Path, artifact1Content)
-
-      const artifact2Content = JSON.stringify({
-        contractName: 'MyToken',
-        abi: [],
-        bytecode: '0x608060405234801561001057600080fd5b50222222'
-      })
-      const artifact2Path = path.join(tempDir, 'legacy', 'MyToken.json')
-      await fs.mkdir(path.dirname(artifact2Path), { recursive: true })
-      await fs.writeFile(artifact2Path, artifact2Content)
-
-      await repository.loadFrom(tempDir)
-    })
-
-    it('should identify ambiguous references correctly', () => {
-      const ambiguousRefs = repository.getAmbiguousReferences()
-      expect(ambiguousRefs).toContain('MyToken')
-    })
-
-    it('should allow lookup by unique hash', () => {
-      const contracts = repository.getAll()
-      const contract1 = contracts.find(c => c.creationCode.includes('111111'))
-      const contract2 = contracts.find(c => c.creationCode.includes('222222'))
-
-      expect(contract1).toBeDefined()
-      expect(contract2).toBeDefined()
-
-      const lookupResult1 = repository.lookup(contract1!.uniqueHash)
-      const lookupResult2 = repository.lookup(contract2!.uniqueHash)
-
-      expect(lookupResult1).toBe(contract1)
-      expect(lookupResult2).toBe(contract2)
-    })
-
-    it('should allow lookup by unambiguous path', () => {
-      const contracts = repository.getAll()
-      const contract1 = contracts.find(c => c.creationCode.includes('111111'))
-
-      const lookupResult = repository.lookup(path.join(tempDir, 'contracts', 'MyToken.json'))
-      expect(lookupResult).toBe(contract1)
-    })
-  })
-
-  describe('lookup method', () => {
-    beforeEach(async () => {
-      const artifactContent = JSON.stringify({
-        contractName: 'UniqueContract',
-        abi: [{ type: 'function', name: 'test' }],
-        bytecode: '0x608060405234801561001057600080fd5b50'
-      })
-      const artifactPath = path.join(tempDir, 'UniqueContract.json')
-      await fs.writeFile(artifactPath, artifactContent)
-
-      await repository.loadFrom(tempDir)
-    })
-
-    it('should successfully lookup by contract name', () => {
-      const contract = repository.lookup('UniqueContract')
-      expect(contract).not.toBeNull()
-      expect(contract!.contractName).toBe('UniqueContract')
-    })
-
-    it('should successfully lookup by unique hash', () => {
-      const contracts = repository.getAll()
-      const testContract = contracts[0]
-      
-      const contract = repository.lookup(testContract.uniqueHash)
-      expect(contract).toBe(testContract)
-    })
-
-    it('should successfully lookup by file path', () => {
-      const artifactPath = path.join(tempDir, 'UniqueContract.json')
-      const contract = repository.lookup(artifactPath)
-      expect(contract).not.toBeNull()
-      expect(contract!.contractName).toBe('UniqueContract')
-    })
-
-    it('should return null for non-existent references', () => {
-      const contract = repository.lookup('NonExistentContract')
-      expect(contract).toBeNull()
-    })
-
-    it('should throw error for ambiguous references', async () => {
-      // Add another contract with the same name
-      const artifact2Content = JSON.stringify({
-        contractName: 'UniqueContract',
-        abi: [],
-        bytecode: '0x608060405234801561001057600080fd5b50222222'
-      })
-      const artifact2Path = path.join(tempDir, 'other', 'UniqueContract.json')
-      await fs.mkdir(path.dirname(artifact2Path), { recursive: true })
-      await fs.writeFile(artifact2Path, artifact2Content)
-
-      // Reload to pick up the new file
-      repository = new ContractRepository()
-      await repository.loadFrom(tempDir)
-
-      expect(() => {
-        repository.lookup('UniqueContract')
-      }).toThrow(/Ambiguous contract reference/)
-    })
-  })
-
-  describe('edge cases', () => {
-    it('should handle directories with no contract files', async () => {
-      const emptyDir = path.join(tempDir, 'empty')
-      await fs.mkdir(emptyDir, { recursive: true })
-
-      await repository.loadFrom(emptyDir)
-
-      const contracts = repository.getAll()
-      expect(contracts).toHaveLength(0)
-    })
-
-    it('should ignore invalid JSON files', async () => {
-      const invalidJsonPath = path.join(tempDir, 'invalid.json')
-      await fs.writeFile(invalidJsonPath, 'invalid json content')
-
-      const validArtifactContent = JSON.stringify({
-        contractName: 'ValidContract',
-        abi: [],
-        bytecode: '0x608060405234801561001057600080fd5b50'
-      })
-      const validArtifactPath = path.join(tempDir, 'valid.json')
-      await fs.writeFile(validArtifactPath, validArtifactContent)
-
-      await repository.loadFrom(tempDir)
-
-      const contracts = repository.getAll()
-      expect(contracts).toHaveLength(1)
-      expect(contracts[0].contractName).toBe('ValidContract')
-    })
-
-    it('should ignore files that are not artifacts or build-info', async () => {
-      const nonArtifactContent = JSON.stringify({
-        name: 'not an artifact',
-        value: 'some data'
-      })
-      const nonArtifactPath = path.join(tempDir, 'notartifact.json')
-      await fs.writeFile(nonArtifactPath, nonArtifactContent)
-
-      await repository.loadFrom(tempDir)
-
-      const contracts = repository.getAll()
-      expect(contracts).toHaveLength(0)
-    })
-  })
-})

package/src/lib/contracts/repository.ts

@@ -1,313 +0,0 @@
-import * as fs from 'fs/promises'
-import * as path from 'path'
-import { createHash } from 'crypto'
-import { Contract } from '../types/contracts'
-import { parseArtifact } from '../parsers/artifact'
-import { parseBuildInfo, isBuildInfoFile } from '../parsers/buildinfo'
-
-export class ContractRepository {
-  private contracts: Map<string, Contract> = new Map()
-  private referenceMap: Map<string, string[]> = new Map()
-  private ambiguousReferences: Set<string> = new Set()
-
-  /**
-   * Main entry point that orchestrates the discovery and hydration process
-   */
-  public async loadFrom(projectRoot: string): Promise<void> {
-    // Step 1: Discover all .json files
-    const files = await this.findContractFiles(projectRoot)
-
-    // Step 2: Parse and hydrate contracts from all discovered files
-    for (const filePath of files) {
-      try {
-        const content = await fs.readFile(filePath, 'utf-8')
-        await this.parseAndHydrateFromFile(content, filePath)
-      } catch (error) {
-        // Silently ignore files that can't be read or parsed
-      }
-    }
-
-    // Step 3: Build reference maps and identify ambiguous references
-    this.disambiguateReferences()
-  }
-
-  /**
-   * Parse a file as both artifact and build-info, then hydrate contracts
-   */
-  private async parseAndHydrateFromFile(content: string, filePath: string): Promise<void> {
-    // Try parsing as build-info file first
-    if (isBuildInfoFile(filePath)) {
-      const extractedContracts = parseBuildInfo(content, filePath)
-      if (extractedContracts) {
-        for (const extracted of extractedContracts) {
-          this.hydrateContract({
-            creationCode: extracted.bytecode,
-            runtimeBytecode: extracted.deployedBytecode,
-            abi: extracted.abi,
-            sourceName: extracted.sourceName,
-            contractName: extracted.contractName,
-            source: extracted.source,
-            compiler: extracted.compiler,
-            buildInfoId: extracted.buildInfoId,
-          }, filePath)
-        }
-        return
-      }
-    }
-
-    // Try parsing as regular artifact
-    const parsed = parseArtifact(content, filePath)
-    if (parsed) {
-      this.hydrateContract({
-        creationCode: parsed.bytecode,
-        runtimeBytecode: parsed.deployedBytecode,
-        abi: parsed.abi,
-        sourceName: parsed.sourceName,
-        contractName: parsed.contractName,
-        source: parsed.source,
-        compiler: parsed.compiler,
-      }, filePath)
-    }
-  }
-
-  /**
-   * Hydrates a contract object with data from a source file
-   */
-  private hydrateContract(data: {
-    creationCode: string
-    runtimeBytecode?: string
-    abi?: any[]
-    sourceName?: string
-    contractName?: string
-    source?: string
-    compiler?: any
-    buildInfoId?: string
-  }, sourceFilePath: string): void {
-    // Validate that we have creation code for hashing (but allow empty string)
-    if (data.creationCode === null || data.creationCode === undefined) {
-      throw new Error(`Cannot hydrate contract from ${sourceFilePath}: missing creation code`)
-    }
-    
-    // Calculate unique hash based on creation code
-    const uniqueHash = createHash('sha256').update(data.creationCode).digest('hex')
-
-    // Get existing contract or create new one
-    let contract = this.contracts.get(uniqueHash)
-    if (!contract) {
-      contract = {
-        uniqueHash,
-        creationCode: data.creationCode,
-        _sources: new Set<string>()
-      }
-      this.contracts.set(uniqueHash, contract)
-    }
-
-    // Add source file to tracking
-    contract._sources.add(sourceFilePath)
-
-    // Hydrate with new information - prefer more complete information
-    // For build-info sources, prefer their data over artifact data
-    const isFromBuildInfo = sourceFilePath.includes('/build-info/')
-    
-    if (data.runtimeBytecode && (!contract.runtimeBytecode || isFromBuildInfo)) {
-      contract.runtimeBytecode = data.runtimeBytecode
-    }
-    if (data.abi && (!contract.abi || contract.abi.length === 0 || isFromBuildInfo)) {
-      contract.abi = data.abi
-    }
-    if (data.sourceName && (!contract.sourceName || isFromBuildInfo)) {
-      contract.sourceName = data.sourceName
-    }
-    if (data.contractName && (!contract.contractName || isFromBuildInfo)) {
-      contract.contractName = data.contractName
-    }
-    if (data.source && (!contract.source || isFromBuildInfo)) {
-      contract.source = data.source
-    }
-    if (data.compiler && (!contract.compiler || isFromBuildInfo)) {
-      contract.compiler = data.compiler
-    }
-    if (data.buildInfoId && !contract.buildInfoId) {
-      contract.buildInfoId = data.buildInfoId
-    }
-  }
-
-  /**
-   * Builds reference maps and identifies ambiguous references
-   */
-  public disambiguateReferences(): void {
-    this.referenceMap.clear()
-    this.ambiguousReferences.clear()
-
-    // Build reference map
-    for (const contract of this.contracts.values()) {
-      const references: string[] = []
-
-      // Add contract name reference
-      if (contract.contractName) {
-        references.push(contract.contractName)
-      }
-
-      // Add sourceName:contractName reference
-      if (contract.sourceName && contract.contractName) {
-        references.push(`${contract.sourceName}:${contract.contractName}`)
-      }
-
-      // Add file paths from sources (excluding build-info files since they can contain multiple contracts)
-      for (const sourcePath of contract._sources) {
-        // Skip build-info files as they legitimately contain multiple contracts
-        if (!isBuildInfoFile(sourcePath)) {
-          references.push(sourcePath)
-          
-          // Add relative paths (both forward and backward variants)
-          const relativePath = path.relative(process.cwd(), sourcePath)
-          if (relativePath !== sourcePath) {
-            references.push(relativePath)
-          }
-        }
-      }
-
-      // For each reference, add the contract's uniqueHash to the reference map
-      for (const ref of references) {
-        if (!this.referenceMap.has(ref)) {
-          this.referenceMap.set(ref, [])
-        }
-        if (!this.referenceMap.get(ref)!.includes(contract.uniqueHash)) {
-          this.referenceMap.get(ref)!.push(contract.uniqueHash)
-        }
-      }
-    }
-
-    // Identify ambiguous references
-    for (const [reference, hashes] of this.referenceMap.entries()) {
-      if (hashes.length > 1) {
-        this.ambiguousReferences.add(reference)
-      }
-    }
-  }
-
-  /**
-   * Lookup a contract by reference
-   * @param reference The contract reference string
-   * @param contextPath Optional file path context for resolving relative paths
-   */
-  public lookup(reference: string, contextPath?: string): Contract | null {
-    let resolvedReference = reference
-    
-    // Handle relative path resolution if contextPath is provided
-    if (contextPath && (reference.startsWith('./') || reference.startsWith('../'))) {
-      resolvedReference = path.resolve(path.dirname(contextPath), reference)
-    }
-    
-    // Handle build-info file:contract references (e.g., "./build-info/file.json:ContractName")
-    if (resolvedReference.includes(':')) {
-      const colonIndex = resolvedReference.lastIndexOf(':')
-      const filePath = resolvedReference.substring(0, colonIndex)
-      const contractName = resolvedReference.substring(colonIndex + 1)
-      
-      // Check if this looks like a build-info file reference
-      if (isBuildInfoFile(filePath)) {
-        // Find contract that came from this specific file with this specific contract name
-        for (const contract of this.contracts.values()) {
-          if (contract.contractName === contractName && contract._sources.has(filePath)) {
-            return contract
-          }
-        }
-        // If not found, return null (will be handled by the error in resolver)
-        return null
-      }
-    }
-    
-    // Check if reference is ambiguous
-    if (this.ambiguousReferences.has(resolvedReference)) {
-      const hashes = this.referenceMap.get(resolvedReference) || []
-      const conflictingSources = hashes.map(hash => {
-        const contract = this.contracts.get(hash)
-        return contract ? Array.from(contract._sources).join(', ') : 'unknown'
-      })
-      throw new Error(`Ambiguous contract reference "${resolvedReference}". Found in multiple contracts: ${conflictingSources.join(' | ')}`)
-    }
-
-    // Check if it's a direct unique hash
-    if (this.contracts.has(resolvedReference)) {
-      return this.contracts.get(resolvedReference)!
-    }
-
-    // Look up in reference map
-    const hashes = this.referenceMap.get(resolvedReference)
-    if (hashes && hashes.length === 1) {
-      return this.contracts.get(hashes[0]) || null
-    }
-
-    return null
-  }
-
-  /**
-   * Get all contracts in the repository
-   */
-  public getAll(): Contract[] {
-    return Array.from(this.contracts.values())
-  }
-
-  /**
-   * Get all ambiguous references
-   */
-  public getAmbiguousReferences(): string[] {
-    return Array.from(this.ambiguousReferences)
-  }
-
-  /**
-   * Add a contract directly to the repository (for testing purposes)
-   * @param contractData - Contract data in the old Artifact format for compatibility
-   */
-  public addForTesting(contractData: {
-    contractName: string
-    abi: any[]
-    bytecode: string
-    deployedBytecode?: string
-    sourceName?: string
-    source?: string
-    compiler?: any
-    buildInfoId?: string
-    _path: string
-    _hash: string
-  }): void {
-    this.hydrateContract({
-      creationCode: contractData.bytecode,
-      runtimeBytecode: contractData.deployedBytecode,
-      abi: contractData.abi,
-      sourceName: contractData.sourceName,
-      contractName: contractData.contractName,
-      source: contractData.source,
-      compiler: contractData.compiler,
-      buildInfoId: contractData.buildInfoId,
-    }, contractData._path)
-
-    // For testing, immediately disambiguate references after adding
-    this.disambiguateReferences()
-  }
-
-  /**
-   * Recursively finds all files that might contain contracts (e.g., .json files)
-   */
-  private async findContractFiles(dir: string, ignoreDirs: Set<string> = new Set(['node_modules', 'dist', '.git', '.idea', '.vscode'])): Promise<string[]> {
-    let results: string[] = []
-    try {
-      const list = await fs.readdir(dir, { withFileTypes: true })
-
-      for (const dirent of list) {
-        const fullPath = path.resolve(dir, dirent.name)
-        if (dirent.isDirectory()) {
-          if (!ignoreDirs.has(dirent.name)) {
-            results = results.concat(await this.findContractFiles(fullPath, ignoreDirs))
-          }
-        } else if (dirent.isFile() && dirent.name.endsWith('.json')) {
-          results.push(fullPath)
-        }
-      }
-    } catch (err) {
-      // Ignore errors from trying to read directories we don't have access to
-    }
-    return results
-  }
-}

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

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