hardhat-external-artifacts 0.0.5 → 0.0.6

package/src/artifacts/converter.ts

@@ -1,5 +1,5 @@
 import type {ExternalArtifact, RichArtifact, LinkReferences} from './types.js';
-import {isRichArtifact} from './types.js';
+import {hasSolcInput, hasMetadata, hasEvmData} from './types.js';
 
 export interface SyntheticCompilation {
 	solcVersion: string;
@@ -15,6 +15,8 @@ interface CompilerInput {
 		outputSelection: Record<string, Record<string, string[]>>;
 		remappings?: string[];
 		metadata?: {useLiteralContent?: boolean; bytecodeHash?: string};
+		evmVersion?: string;
+		viaIR?: boolean;
 	};
 }
 
@@ -50,6 +52,17 @@ interface BytecodeOutput {
 	functionDebugData?: Record<string, any>;
 }
 
+/**
+ * Extracted compilation context from an artifact.
+ * Used to group artifacts that share the same compilation settings.
+ */
+interface CompilationContext {
+	solcVersion: string;
+	compilerInput: CompilerInput | null;
+	/** Key for grouping artifacts with same compilation context */
+	groupKey: string;
+}
+
 /**
  * Creates a minimal valid AST for a source file.
  * This is needed because Hardhat's contract decoder expects a valid AST structure.
@@ -92,203 +105,222 @@ function createMinimalAst(
 }
 
 /**
- * Convert artifacts to compilation format.
- * If artifacts are "rich" (have solcInput), use the embedded data.
- * Otherwise, synthesize a minimal compilation.
+ * Extract compilation context from an artifact.
+ * Tries solcInput first, then falls back to metadata, then defaults.
  */
-export function artifactsToCompilations(
-	artifacts: ExternalArtifact[],
+function extractCompilationContext(
+	artifact: ExternalArtifact,
 	defaultSolcVersion: string,
 	debug: boolean = false,
-): SyntheticCompilation[] {
-	// Group artifacts by whether they have solcInput
-	const richArtifacts = artifacts.filter(isRichArtifact);
-	const simpleArtifacts = artifacts.filter((a) => !isRichArtifact(a));
-
-	if (debug) {
-		console.log(`[external-artifacts] Processing ${artifacts.length} artifacts:`);
-		console.log(`  - Rich artifacts (with solcInput): ${richArtifacts.length}`);
-		console.log(`  - Simple artifacts: ${simpleArtifacts.length}`);
-		for (const artifact of artifacts) {
-			const isRich = isRichArtifact(artifact);
-			const richArt = artifact as Partial<RichArtifact>;
-			const immRefs = richArt.evm?.deployedBytecode?.immutableReferences ?? artifact.immutableReferences;
-			const immCount = immRefs ? Object.keys(immRefs).length : 0;
-			console.log(`  - ${artifact.contractName}: ${isRich ? 'rich' : 'simple'}, immutableReferences: ${immCount} keys`);
+): CompilationContext {
+	// Try to extract from solcInput first (most complete)
+	if (hasSolcInput(artifact)) {
+		try {
+			const compilerInput: CompilerInput = JSON.parse(artifact.solcInput);
+			const solcVersion = extractVersionFromMetadata(artifact.metadata) ?? defaultSolcVersion;
+			// Use a hash of settings to group artifacts with same compilation context
+			const settingsKey = JSON.stringify(compilerInput.settings);
+			return {
+				solcVersion,
+				compilerInput,
+				groupKey: `solcInput:${solcVersion}:${hashString(settingsKey)}`,
+			};
+		} catch (e) {
+			if (debug) {
+				console.log(`[external-artifacts] Failed to parse solcInput for ${artifact.contractName}: ${e}`);
+			}
+			// Fall through to metadata extraction
 		}
 	}
 
-	const compilations: SyntheticCompilation[] = [];
-
-	// Process rich artifacts - these have embedded solcInput
-	for (const artifact of richArtifacts) {
-		const compilation = richArtifactToCompilation(artifact, debug);
-		if (compilation) {
-			compilations.push(compilation);
+	// Try to extract from metadata (partial but useful)
+	if (hasMetadata(artifact)) {
+		try {
+			const metadata = JSON.parse(artifact.metadata);
+			const solcVersion = extractVersionFromMetadataObject(metadata) ?? defaultSolcVersion;
+			const compilerInput = metadataToCompilerInput(metadata);
+			if (compilerInput) {
+				const settingsKey = JSON.stringify(compilerInput.settings);
+				return {
+					solcVersion,
+					compilerInput,
+					groupKey: `metadata:${solcVersion}:${hashString(settingsKey)}`,
+				};
+			}
+		} catch (e) {
+			if (debug) {
+				console.log(`[external-artifacts] Failed to parse metadata for ${artifact.contractName}: ${e}`);
+			}
+			// Fall through to defaults
 		}
 	}
 
-	// Process simple artifacts - synthesize compilation
-	if (simpleArtifacts.length > 0) {
-		compilations.push(
-			synthesizeCompilation(simpleArtifacts, defaultSolcVersion, debug),
-		);
-	}
-
-	return compilations;
+	// Default: no compiler input available, use defaults
+	return {
+		solcVersion: defaultSolcVersion,
+		compilerInput: null,
+		groupKey: `default:${defaultSolcVersion}`,
+	};
 }
 
 /**
- * Convert a rich artifact (with embedded solcInput) to a compilation.
- * Uses the embedded solcInput directly for maximum fidelity.
+ * Extract solc version from metadata string.
  */
-function richArtifactToCompilation(
-	artifact: RichArtifact,
-	debug: boolean = false,
-): SyntheticCompilation | null {
-	if (!artifact.solcInput) {
+function extractVersionFromMetadata(metadataStr?: string): string | null {
+	if (!metadataStr) return null;
+	try {
+		const metadata = JSON.parse(metadataStr);
+		return extractVersionFromMetadataObject(metadata);
+	} catch {
 		return null;
 	}
+}
 
-	// Parse the embedded solcInput
-	const compilerInput: CompilerInput = JSON.parse(artifact.solcInput);
+/**
+ * Extract solc version from parsed metadata object.
+ */
+function extractVersionFromMetadataObject(metadata: any): string | null {
+	if (metadata?.compiler?.version) {
+		// Format: "0.8.10+commit.fc410830" -> extract "0.8.10"
+		return metadata.compiler.version.split('+')[0];
+	}
+	return null;
+}
 
-	// Extract solc version from metadata
-	let solcVersion = '0.8.20'; // Default
-	if (artifact.metadata) {
-		try {
-			const metadata = JSON.parse(artifact.metadata);
-			if (metadata.compiler?.version) {
-				// Format: "0.8.10+commit.fc410830" -> extract "0.8.10"
-				solcVersion = metadata.compiler.version.split('+')[0];
-			}
-		} catch {
-			// Ignore parsing errors, use default
+/**
+ * Convert metadata to compiler input.
+ * Metadata contains settings but not full source content.
+ */
+function metadataToCompilerInput(metadata: any): CompilerInput | null {
+	if (!metadata?.settings) return null;
+
+	const settings = metadata.settings;
+	const sources: Record<string, {content: string}> = {};
+
+	// Metadata has source hashes but not content
+	// We'll add empty placeholders that get filled in later
+	if (metadata.sources) {
+		for (const sourceName of Object.keys(metadata.sources)) {
+			// Some metadata includes content in keccak256 only
+			// We use empty content as placeholder
+			sources[sourceName] = {content: ''};
 		}
 	}
 
-	// Build compiler output from the artifact
-	// Only include sources that we have contract data for
-	// Including empty sources/contracts can cause EDR selector fixup issues
-	const compilerOutput: CompilerOutput = {
-		sources: {},
-		contracts: {},
+	return {
+		language: metadata.language ?? 'Solidity',
+		sources,
+		settings: {
+			optimizer: settings.optimizer ?? {enabled: false},
+			outputSelection: settings.outputSelection ?? {
+				'*': {'*': ['abi', 'evm.bytecode', 'evm.deployedBytecode']},
+			},
+			remappings: settings.remappings,
+			metadata: settings.metadata,
+			evmVersion: settings.evmVersion,
+			viaIR: settings.viaIR,
+		},
 	};
+}
 
-	const sourceName = artifact.sourceName;
+/**
+ * Simple string hash for grouping.
+ */
+function hashString(str: string): string {
+	let hash = 0;
+	for (let i = 0; i < str.length; i++) {
+		const char = str.charCodeAt(i);
+		hash = ((hash << 5) - hash) + char;
+		hash = hash & hash; // Convert to 32-bit integer
+	}
+	return hash.toString(16);
+}
 
-	// Track source IDs for all input sources (needed for consistent source indexing)
-	let sourceId = 0;
-	const sourceIds: Record<string, number> = {};
-	for (const srcName of Object.keys(compilerInput.sources)) {
-		sourceIds[srcName] = sourceId++;
+/**
+ * Convert artifacts to compilation format.
+ * Flexibly extracts data from each artifact - uses solcInput if available,
+ * falls back to metadata for settings, or synthesizes minimal compilation.
+ */
+export function artifactsToCompilations(
+	artifacts: ExternalArtifact[],
+	defaultSolcVersion: string,
+	debug: boolean = false,
+): SyntheticCompilation[] {
+	if (debug) {
+		console.log(`[external-artifacts] Processing ${artifacts.length} artifacts`);
 	}
 
-	// Only include the source that contains our contract
-	const contractSourceId = sourceIds[sourceName] ?? sourceId++;
-	const contractNodeId = contractSourceId + 1000; // Use an offset to avoid ID conflicts
+	// Extract context from each artifact and group by compilation context
+	const artifactsByContext: Map<string, {
+		context: CompilationContext;
+		artifacts: ExternalArtifact[];
+	}> = new Map();
 
-	compilerOutput.sources[sourceName] = {
-		id: contractSourceId,
-		ast: createMinimalAst(sourceName, contractSourceId, [
-			{name: artifact.contractName, nodeId: contractNodeId},
-		]),
-	};
-	compilerOutput.contracts[sourceName] = {};
+	for (const artifact of artifacts) {
+		const context = extractCompilationContext(artifact, defaultSolcVersion, debug);
+		const richArt = artifact as Partial<RichArtifact>;
+		const immRefs = richArt.evm?.deployedBytecode?.immutableReferences ?? artifact.immutableReferences;
+		const immCount = immRefs ? Object.keys(immRefs).length : 0;
 
-	// Ensure the source is in compilerInput as well
-	if (!compilerInput.sources[sourceName]) {
-		compilerInput.sources[sourceName] = {content: ''};
-	}
+		if (debug) {
+			console.log(`  - ${artifact.contractName}: solcInput=${hasSolcInput(artifact)}, metadata=${hasMetadata(artifact)}, immutableReferences=${immCount} keys, group=${context.groupKey}`);
+		}
 
-	// Build bytecode output, ensuring proper format
-	// Standard solc output has bytecode.object without 0x prefix
-	const bytecode: BytecodeOutput = {
-		object: stripHexPrefix(
-			artifact.evm?.bytecode?.object ?? artifact.bytecode ?? '0x',
-		),
-		opcodes: artifact.evm?.bytecode?.opcodes ?? '',
-		sourceMap: artifact.evm?.bytecode?.sourceMap ?? '',
-		linkReferences:
-			artifact.evm?.bytecode?.linkReferences ?? artifact.linkReferences ?? {},
-		generatedSources: artifact.evm?.bytecode?.generatedSources,
-		functionDebugData: artifact.evm?.bytecode?.functionDebugData,
-	};
+		const existing = artifactsByContext.get(context.groupKey);
+		if (existing) {
+			existing.artifacts.push(artifact);
+		} else {
+			artifactsByContext.set(context.groupKey, {
+				context,
+				artifacts: [artifact],
+			});
+		}
+	}
 
-	const deployedBytecode: BytecodeOutput = {
-		object: stripHexPrefix(
-			artifact.evm?.deployedBytecode?.object ??
-				artifact.deployedBytecode ??
-				'0x',
-		),
-		opcodes: artifact.evm?.deployedBytecode?.opcodes ?? '',
-		sourceMap: artifact.evm?.deployedBytecode?.sourceMap ?? '',
-		linkReferences:
-			artifact.evm?.deployedBytecode?.linkReferences ??
-			artifact.deployedLinkReferences ??
-			{},
-		immutableReferences:
-			artifact.evm?.deployedBytecode?.immutableReferences ??
-			artifact.immutableReferences ??
-			{},
-		generatedSources: artifact.evm?.deployedBytecode?.generatedSources,
-		functionDebugData: artifact.evm?.deployedBytecode?.functionDebugData,
-	};
+	if (debug) {
+		console.log(`[external-artifacts] Grouped into ${artifactsByContext.size} compilations`);
+	}
 
-	// IMPORTANT: Do NOT provide method identifiers - let EDR compute them
-	// EDR has internal "selector fixup" logic for function overloading that can fail
-	// if we provide method identifiers that it then tries to reconcile with AST info.
-	// The error "Failed to fix up the selector for ... #supportsInterface" happens
-	// when EDR can't match provided selectors with overloaded functions.
-	// By providing an empty object, EDR will compute selectors from the ABI directly.
-	const methodIdentifiers: Record<string, string> = {};
-
-	compilerOutput.contracts[sourceName][artifact.contractName] = {
-		abi: artifact.abi,
-		evm: {
-			bytecode,
-			deployedBytecode,
-			methodIdentifiers,
-		},
-		metadata: artifact.metadata,
-		devdoc: artifact.devdoc,
-		userdoc: artifact.userdoc,
-		storageLayout: artifact.storageLayout,
-	};
+	// Convert each group to a compilation
+	const compilations: SyntheticCompilation[] = [];
 
-	if (debug) {
-		const immRefKeys = Object.keys(deployedBytecode.immutableReferences ?? {});
-		console.log(`[external-artifacts] Rich artifact: ${artifact.contractName}`);
-		console.log(`  - sourceName: ${sourceName}`);
-		console.log(`  - solcVersion: ${solcVersion}`);
-		console.log(`  - immutableReferences keys: ${immRefKeys.length}`);
-		if (immRefKeys.length > 0) {
-			console.log(`  - immutableReferences sample:`, JSON.stringify(deployedBytecode.immutableReferences, null, 2).slice(0, 500));
-		}
-		console.log(`  - deployedBytecode length: ${deployedBytecode.object.length / 2} bytes`);
+	for (const {context, artifacts: groupArtifacts} of artifactsByContext.values()) {
+		const compilation = buildCompilation(groupArtifacts, context, debug);
+		compilations.push(compilation);
 	}
 
-	return {
-		solcVersion,
-		compilerInput,
-		compilerOutput,
-	};
+	return compilations;
 }
 
 /**
- * Synthesize a minimal compilation from simple artifacts.
- * Used when artifacts don't have embedded solcInput.
+ * Build a compilation from a group of artifacts sharing the same context.
+ * Flexibly extracts available data from each artifact.
  */
-function synthesizeCompilation(
+function buildCompilation(
 	artifacts: ExternalArtifact[],
-	solcVersion: string,
+	context: CompilationContext,
 	debug: boolean = false,
 ): SyntheticCompilation {
-	const sources: CompilerInput['sources'] = {};
-	const outputSources: CompilerOutput['sources'] = {};
-	const contracts: CompilerOutput['contracts'] = {};
+	// Start with context's compiler input or create a minimal one
+	const compilerInput: CompilerInput = context.compilerInput
+		? {...context.compilerInput, sources: {...context.compilerInput.sources}}
+		: {
+			language: 'Solidity',
+			sources: {},
+			settings: {
+				optimizer: {enabled: false},
+				outputSelection: {
+					'*': {'*': ['abi', 'evm.bytecode', 'evm.deployedBytecode']},
+				},
+			},
+		};
+
+	const compilerOutput: CompilerOutput = {
+		sources: {},
+		contracts: {},
+	};
 
-	// First, group artifacts by source
+	// Group artifacts by source for AST generation
 	const contractsBySource: Record<
 		string,
 		Array<{name: string; artifact: ExternalArtifact}>
@@ -303,92 +335,115 @@ function synthesizeCompilation(
 		});
 	}
 
-	// Track IDs for AST nodes
-	let nextId = 0;
+	// Track source IDs - use existing ones from compiler input if available
+	let nextSourceId = 0;
+	const sourceIds: Record<string, number> = {};
+	for (const srcName of Object.keys(compilerInput.sources)) {
+		sourceIds[srcName] = nextSourceId++;
+	}
 
-	// Create sources with contract definitions in AST
-	for (const [sourceName, sourceContracts] of Object.entries(
-		contractsBySource,
-	)) {
-		const sourceId = nextId++;
-		sources[sourceName] = {content: ''};
-		contracts[sourceName] = {};
+	// Track node IDs for AST
+	let nextNodeId = nextSourceId + 1000; // Offset to avoid conflicts
+
+	// Process each source
+	for (const [sourceName, sourceContracts] of Object.entries(contractsBySource)) {
+		// Ensure source exists in compiler input
+		if (!compilerInput.sources[sourceName]) {
+			compilerInput.sources[sourceName] = {content: ''};
+		}
+
+		// Get or assign source ID
+		const sourceId = sourceIds[sourceName] ?? nextSourceId++;
+		sourceIds[sourceName] = sourceId;
 
 		// Create contract nodes for AST
 		const contractNodes: Array<{name: string; nodeId: number}> = [];
 		for (const {name} of sourceContracts) {
-			const nodeId = nextId++;
-			contractNodes.push({name, nodeId});
+			contractNodes.push({name, nodeId: nextNodeId++});
 		}
 
-		outputSources[sourceName] = {
+		compilerOutput.sources[sourceName] = {
 			id: sourceId,
 			ast: createMinimalAst(sourceName, sourceId, contractNodes),
 		};
 
+		compilerOutput.contracts[sourceName] = {};
+
 		// Add contract outputs
 		for (const {name, artifact} of sourceContracts) {
-			// Cast to access optional evm property that may exist on artifacts
-			// without solcInput (partial RichArtifact)
 			const richArtifact = artifact as Partial<RichArtifact>;
 
+			// Build bytecode output, extracting from evm if available
+			const bytecode: BytecodeOutput = {
+				object: stripHexPrefix(
+					richArtifact.evm?.bytecode?.object ?? artifact.bytecode ?? '0x',
+				),
+				opcodes: richArtifact.evm?.bytecode?.opcodes ?? '',
+				sourceMap: richArtifact.evm?.bytecode?.sourceMap ?? '',
+				linkReferences:
+					richArtifact.evm?.bytecode?.linkReferences ?? artifact.linkReferences ?? {},
+				generatedSources: richArtifact.evm?.bytecode?.generatedSources,
+				functionDebugData: richArtifact.evm?.bytecode?.functionDebugData,
+			};
+
 			const immutableReferences =
 				richArtifact.evm?.deployedBytecode?.immutableReferences ??
 				artifact.immutableReferences ??
 				{};
 
-			contracts[sourceName][name] = {
+			const deployedBytecode: BytecodeOutput = {
+				object: stripHexPrefix(
+					richArtifact.evm?.deployedBytecode?.object ??
+						artifact.deployedBytecode ??
+						'0x',
+				),
+				opcodes: richArtifact.evm?.deployedBytecode?.opcodes ?? '',
+				sourceMap: richArtifact.evm?.deployedBytecode?.sourceMap ?? '',
+				linkReferences:
+					richArtifact.evm?.deployedBytecode?.linkReferences ??
+					artifact.deployedLinkReferences ??
+					{},
+				immutableReferences,
+				generatedSources: richArtifact.evm?.deployedBytecode?.generatedSources,
+				functionDebugData: richArtifact.evm?.deployedBytecode?.functionDebugData,
+			};
+
+			// IMPORTANT: Do NOT provide method identifiers - let EDR compute them
+			// EDR has internal "selector fixup" logic for function overloading that can fail
+			// if we provide method identifiers that it then tries to reconcile with AST info.
+			compilerOutput.contracts[sourceName][name] = {
 				abi: artifact.abi,
 				evm: {
-					bytecode: {
-						object: stripHexPrefix(artifact.bytecode),
-						opcodes: '',
-						sourceMap: '',
-						linkReferences: artifact.linkReferences ?? {},
-					},
-					deployedBytecode: {
-						object: stripHexPrefix(artifact.deployedBytecode),
-						opcodes: '',
-						sourceMap: '',
-						linkReferences: artifact.deployedLinkReferences ?? {},
-						// Check both evm.deployedBytecode.immutableReferences and top-level
-						immutableReferences,
-					},
-					// Empty object - let EDR compute selectors to avoid selector fixup issues
-					// with overloaded functions (consistent with richArtifactToCompilation)
+					bytecode,
+					deployedBytecode,
 					methodIdentifiers: {},
 				},
+				metadata: richArtifact.metadata,
+				devdoc: richArtifact.devdoc,
+				userdoc: richArtifact.userdoc,
+				storageLayout: richArtifact.storageLayout,
 			};
 
 			if (debug) {
 				const immRefKeys = Object.keys(immutableReferences);
-				console.log(`[external-artifacts] Simple artifact: ${name}`);
+				console.log(`[external-artifacts] Built artifact: ${name}`);
 				console.log(`  - sourceName: ${sourceName}`);
+					console.log(`  - hasSolcInput: ${hasSolcInput(artifact)}`);
+					console.log(`  - hasMetadata: ${hasMetadata(artifact)}`);
+					console.log(`  - hasEvmData: ${hasEvmData(artifact)}`);
 				console.log(`  - immutableReferences keys: ${immRefKeys.length}`);
 				if (immRefKeys.length > 0) {
 					console.log(`  - immutableReferences sample:`, JSON.stringify(immutableReferences, null, 2).slice(0, 500));
 				}
-				console.log(`  - deployedBytecode length: ${artifact.deployedBytecode.length / 2} bytes`);
+				console.log(`  - deployedBytecode length: ${deployedBytecode.object.length / 2} bytes`);
 			}
 		}
 	}
 
 	return {
-		solcVersion,
-		compilerInput: {
-			language: 'Solidity',
-			sources,
-			settings: {
-				optimizer: {enabled: false},
-				outputSelection: {
-					'*': {'*': ['abi', 'evm.bytecode', 'evm.deployedBytecode']},
-				},
-			},
-		},
-		compilerOutput: {
-			sources: outputSources,
-			contracts,
-		},
+		solcVersion: context.solcVersion,
+		compilerInput,
+		compilerOutput,
 	};
 }
 

package/src/artifacts/types.ts

@@ -83,12 +83,34 @@ export interface LinkReferences {
 }
 
 /**
- * Type guard to check if an artifact is a rich artifact
+ * Type guard to check if an artifact has solcInput.
+ * Note: The converter now handles artifacts flexibly, extracting
+ * available data from solcInput, metadata, or evm fields without
+ * requiring a strict "rich" vs "simple" classification.
  */
-export function isRichArtifact(
+export function hasSolcInput(
 	artifact: ExternalArtifact,
-): artifact is RichArtifact {
-	return 'solcInput' in artifact && artifact.solcInput !== undefined;
+): artifact is RichArtifact & {solcInput: string} {
+	return 'solcInput' in artifact && typeof (artifact as RichArtifact).solcInput === 'string';
+}
+
+/**
+ * Type guard to check if an artifact has metadata.
+ * Metadata can be used as a fallback for compiler settings when solcInput is not available.
+ */
+export function hasMetadata(
+	artifact: ExternalArtifact,
+): artifact is RichArtifact & {metadata: string} {
+	return 'metadata' in artifact && typeof (artifact as RichArtifact).metadata === 'string';
+}
+
+/**
+ * Type guard to check if an artifact has EVM data.
+ */
+export function hasEvmData(
+	artifact: ExternalArtifact,
+): artifact is RichArtifact & {evm: NonNullable<RichArtifact['evm']>} {
+	return 'evm' in artifact && (artifact as RichArtifact).evm !== undefined;
 }
 
 /**

package/src/hooks/network.ts

@@ -5,7 +5,7 @@ import {
 	artifactsToCompilations,
 	type SyntheticCompilation,
 } from '../artifacts/converter.js';
-import {isRichArtifact} from '../artifacts/types.js';
+import {hasSolcInput} from '../artifacts/types.js';
 
 export default async (): Promise<Partial<NetworkHooks>> => {
 	const handlers: Partial<NetworkHooks> = {
@@ -50,10 +50,10 @@ export default async (): Promise<Partial<NetworkHooks>> => {
 					`[hardhat-external-artifacts] Loaded ${artifacts.length} artifact(s):`,
 				);
 				for (const artifact of artifacts) {
-					const isRich = isRichArtifact(artifact);
+					const hasSolc = hasSolcInput(artifact);
 					const deployedBytecodeLength = artifact.deployedBytecode?.length || 0;
 					log(
-						`  - ${artifact.sourceName}:${artifact.contractName} (${isRich ? 'rich' : 'simple'}, deployedBytecode: ${deployedBytecodeLength} chars)`,
+						`  - ${artifact.sourceName}:${artifact.contractName} (${hasSolc ? 'with solcInput' : 'minimal'}, deployedBytecode: ${deployedBytecodeLength} chars)`,
 					);
 				}