@0xsequence/catapult 1.4.0 → 1.5.0

package/src/lib/contracts/repository.ts

@@ -1,411 +0,0 @@
-import * as fs from 'fs/promises'
-import * as path from 'path'
-import { createHash } from 'crypto'
-import { Contract } from '../types/contracts'
-import { BuildInfoSourceProvenance, SourceProvenance } from '../types/source'
-import { parseArtifact } from '../parsers/artifact'
-import { parseBuildInfo, isBuildInfoFile } from '../parsers/buildinfo'
-import { mergeSourceProvenance, parseSourceDocument } from '../parsers/source'
-
-export class ContractRepository {
-  private contracts: Map<string, Contract> = new Map()
-  private referenceMap: Map<string, string[]> = new Map()
-  private ambiguousReferences: Set<string> = new Set()
-  private sourceProvenanceByBuildInfoPath: Map<string, BuildInfoSourceProvenance> = new Map()
-
-  /**
-   * Main entry point that orchestrates the discovery and hydration process
-   */
-  public async loadFrom(projectRoot: string): Promise<void> {
-    const files = await this.findProjectFiles(projectRoot)
-
-    await this.loadSourceProvenanceFiles(files.sourceFiles)
-
-    for (const filePath of files.contractFiles) {
-      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
-      }
-    }
-
-    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) {
-          const sourceProvenance = this.getSourceProvenance(filePath, extracted.fullyQualifiedName)
-          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,
-            sourceProvenance,
-          }, 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
-    sourceProvenance?: SourceProvenance
-  }, 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>(),
-        _sourceProvenance: new Map<string, SourceProvenance>()
-      }
-      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
-    }
-    if (data.sourceProvenance) {
-      if (!contract._sourceProvenance) {
-        contract._sourceProvenance = new Map<string, SourceProvenance>()
-      }
-      contract._sourceProvenance.set(sourceFilePath, data.sourceProvenance)
-
-      contract.sourceProvenance = this.selectPreferredSourceProvenance(contract._sourceProvenance)
-    }
-  }
-
-  private getSourceProvenance(buildInfoPath: string, fullyQualifiedName: string): SourceProvenance | undefined {
-    const provenance = this.sourceProvenanceByBuildInfoPath.get(buildInfoPath)
-    if (!provenance) {
-      return undefined
-    }
-
-    return mergeSourceProvenance(provenance, provenance.contracts?.[fullyQualifiedName])
-  }
-
-  private selectPreferredSourceProvenance(sourceProvenance: Map<string, SourceProvenance>): SourceProvenance | undefined {
-    const firstEntry = Array.from(sourceProvenance.entries()).sort(([a], [b]) => a.localeCompare(b))[0]
-    return firstEntry?.[1]
-  }
-
-  /**
-   * 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
-    sourceProvenance?: SourceProvenance
-    _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,
-      sourceProvenance: contractData.sourceProvenance,
-    }, contractData._path)
-
-    // For testing, immediately disambiguate references after adding
-    this.disambiguateReferences()
-  }
-
-  private async findProjectFiles(
-    dir: string,
-    ignoreDirs: Set<string> = new Set(['node_modules', 'dist', '.git', '.idea', '.vscode'])
-  ): Promise<{ contractFiles: string[]; sourceFiles: string[] }> {
-    const results: { contractFiles: string[]; sourceFiles: string[] } = {
-      contractFiles: [],
-      sourceFiles: []
-    }
-    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)) {
-            const childResults = await this.findProjectFiles(fullPath, ignoreDirs)
-            results.contractFiles.push(...childResults.contractFiles)
-            results.sourceFiles.push(...childResults.sourceFiles)
-          }
-        } else if (dirent.isFile() && dirent.name.endsWith('.json')) {
-          results.contractFiles.push(fullPath)
-        } else if (dirent.isFile() && (dirent.name === 'source.yaml' || dirent.name === 'source.yml')) {
-          results.sourceFiles.push(fullPath)
-        }
-      }
-    } catch (err) {
-      // Ignore errors from trying to read directories we don't have access to
-    }
-    return results
-  }
-
-  private async loadSourceProvenanceFiles(sourceFiles: string[]): Promise<void> {
-    this.sourceProvenanceByBuildInfoPath.clear()
-
-    for (const sourceFilePath of sourceFiles) {
-      let sourceDocument
-      try {
-        const content = await fs.readFile(sourceFilePath, 'utf-8')
-        sourceDocument = parseSourceDocument(content)
-      } catch (error) {
-        this.warnSourceProvenance(`Skipping source provenance file ${sourceFilePath}: ${error instanceof Error ? error.message : String(error)}`)
-        continue
-      }
-
-      if (!sourceDocument) {
-        continue
-      }
-
-      for (const warning of sourceDocument.warnings || []) {
-        this.warnSourceProvenance(`Skipping source provenance entry ${sourceFilePath}: ${warning}`)
-      }
-
-      const sourceDir = path.dirname(sourceFilePath)
-      for (const [buildInfoRef, provenance] of Object.entries(sourceDocument.build_info)) {
-        const buildInfoPath = path.resolve(sourceDir, buildInfoRef)
-        if (!isBuildInfoFile(buildInfoPath)) {
-          this.warnSourceProvenance(`Skipping source provenance entry ${sourceFilePath}: "${buildInfoRef}" does not point to a build-info JSON file.`)
-          continue
-        }
-
-        if (!await this.pathExists(buildInfoPath)) {
-          this.warnSourceProvenance(`Skipping source provenance entry ${sourceFilePath}: build-info file "${buildInfoRef}" does not exist.`)
-          continue
-        }
-
-        if (this.sourceProvenanceByBuildInfoPath.has(buildInfoPath)) {
-          this.warnSourceProvenance(`Skipping source provenance entry ${sourceFilePath}: duplicate provenance for build-info file "${buildInfoRef}".`)
-          continue
-        }
-
-        this.sourceProvenanceByBuildInfoPath.set(buildInfoPath, {
-          ...provenance,
-          sourceDocumentPath: sourceFilePath,
-          buildInfoPath
-        })
-      }
-    }
-  }
-
-  private async pathExists(filePath: string): Promise<boolean> {
-    try {
-      await fs.access(filePath)
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  private warnSourceProvenance(message: string): void {
-    console.warn(message)
-  }
-}