hardhat-deploy 2.0.0-next.7 → 2.0.0-next.70

package/package.json

@@ -1,54 +1,86 @@
 {
   "name": "hardhat-deploy",
-  "version": "2.0.0-next.7",
-  "description": "deployment plugin for hardhat",
+  "version": "2.0.0-next.70",
+  "description": "Hardhat plugin for replicable smart contract deployments and easy testing across multiple EVM chains, with support for proxies, diamonds, named accounts, and deployment fixtures",
+  "keywords": [
+    "hardhat",
+    "ethereum",
+    "solidity",
+    "deployment",
+    "test",
+    "cli"
+  ],
+  "author": "Ronan Sandford",
+  "license": "MIT",
+  "homepage": "https://github.com/wighawag/hardhat-deploy#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wighawag/hardhat-deploy.git"
+  },
+  "bugs": {
+    "url": "https://github.com/wighawag/hardhat-deploy/issues"
+  },
   "publishConfig": {
     "access": "public"
   },
   "type": "module",
-  "main": "dist/esm/index.js",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/esm/index.d.ts",
+  "main": "dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/esm/index.d.ts",
-        "default": "./dist/esm/index.js"
-      }
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": "./dist/v1-entry.cjs"
     },
     "./helpers": {
       "import": {
-        "types": "./dist/esm/helpers.d.ts",
-        "default": "./dist/esm/helpers.js"
+        "types": "./dist/helpers.d.ts",
+        "default": "./dist/helpers.js"
       }
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "src",
+    "bin",
+    "templates"
   ],
+  "bin": {
+    "hardhat-deploy": "./dist/cli.js"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
   "devDependencies": {
-    "@changesets/cli": "^2.28.1",
-    "@types/node": "^22.13.10",
-    "as-soon": "^0.0.11",
-    "hardhat": "^3.0.0-next.1",
-    "rimraf": "^6.0.1",
-    "rocketh": "1.0.0-next.2",
+    "@changesets/cli": "^2.29.8",
+    "@rocketh/node": "0.17.21",
+    "@types/node": "^25.0.10",
+    "as-soon": "^0.1.5",
+    "hardhat": "3.1.5",
+    "rimraf": "^6.1.2",
+    "rocketh": "0.17.18",
     "set-defaults": "^0.0.5",
-    "typescript": "^5.5.2"
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "hardhat": "^3.0.0-next.1",
-    "rocketh": "1.0.0-next.2"
+    "@rocketh/node": "^0.17.21",
+    "hardhat": "^3.1.5"
   },
   "dependencies": {
-    "@nomicfoundation/hardhat-errors": "3.0.0-next.0",
-    "@nomicfoundation/hardhat-zod-utils": "3.0.0-next.0",
+    "@nomicfoundation/hardhat-zod-utils": "3.0.1",
     "@types/debug": "^4.1.12",
-    "debug": "^4.4.0",
-    "zod": "^3.24.2"
+    "commander": "^14.0.2",
+    "debug": "^4.4.3",
+    "named-logs-console": "^0.5.1",
+    "slash": "^5.1.0",
+    "zod": "^4.3.6"
   },
   "scripts": {
-    "build": "tsc --project tsconfig.json",
-    "dev": "as-soon -w src pnpm build"
+    "build": "tsc --project tsconfig.json && cp src/v1-entry.cjs dist/",
+    "dev": "as-soon -w src pnpm build",
+    "postinstall": "node ./dist/postinstall.js"
   }
 }

package/src/cli.ts

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { readFileSync, readdirSync, mkdirSync, copyFileSync, existsSync, writeFileSync, statSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+import * as readline from 'readline';
+import pkg from '../package.json' with { type: 'json' };
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const program = new Command();
+
+// Get the current version of hardhat-deploy
+const getHardhatDeployVersion = (): string => {
+  return pkg.version;
+};
+
+const askFolder = async (): Promise<string> => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question('Enter folder path (default: ./): ', (answer) => {
+      rl.close();
+      resolve(answer.trim() || './');
+    });
+  });
+};
+
+const askAutoInstall = async (): Promise<boolean> => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question('Auto-install dependencies with pnpm? (Y/n): ', (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      resolve(trimmed === '' || trimmed === 'y' || trimmed === 'yes');
+    });
+  });
+};
+
+const isFolderEmpty = (folderPath: string): boolean => {
+  if (!existsSync(folderPath)) {
+    return true;
+  }
+  
+  try {
+    const files = readdirSync(folderPath);
+    return files.length === 0;
+  } catch (error) {
+    // If we can't read the directory, treat it as not empty
+    return false;
+  }
+};
+
+const copyFile = (
+  source: string,
+  target: string,
+  replacements: Record<string, string> = {},
+  gitignorePatterns: string[] = []
+): void => {
+  const fileName = basename(source);
+  
+  // Check if file should be skipped based on gitignore patterns
+  for (const pattern of gitignorePatterns) {
+    if (fileName === pattern || fileName.endsWith(pattern.replace('*', ''))) {
+      return; // Skip this file
+    }
+  }
+  
+  let content = readFileSync(source, 'utf-8');
+  
+  // Apply replacements
+  for (const [search, replace] of Object.entries(replacements)) {
+    content = content.replaceAll(search, replace);
+  }
+  
+  mkdirSync(dirname(target), { recursive: true });
+  
+  // For binary files, just copy as-is
+  if (source.endsWith('.lock') || source.endsWith('.so') || source.endsWith('.wasm')) {
+    copyFileSync(source, target);
+  } else {
+    writeFileSync(target, content, 'utf-8');
+  }
+};
+
+const parseGitignore = (gitignorePath: string): string[] => {
+  if (!existsSync(gitignorePath)) {
+    return [];
+  }
+  
+  const content = readFileSync(gitignorePath, 'utf-8');
+  return content
+    .split('\n')
+    .map((line: string) => line.trim())
+    .filter((line: string) => line && !line.startsWith('#'));
+};
+
+const copyFolder = (
+  source: string,
+  target: string,
+  replacements: Record<string, string> = {},
+  gitignorePatterns: string[] = []
+): void => {
+  if (!existsSync(target)) {
+    mkdirSync(target, { recursive: true });
+  }
+
+  const files = readdirSync(source);
+
+  files.forEach((file) => {
+    const sourcePath = join(source, file);
+    const targetPath = join(target, file);
+
+    const stat = statSync(sourcePath);
+
+    if (stat.isDirectory()) {
+      // Check if directory should be skipped based on gitignore patterns
+      const shouldSkip = gitignorePatterns.some(pattern =>
+        file === pattern.replace('/', '') || pattern.startsWith('/') && file === pattern.slice(1)
+      );
+      
+      if (!shouldSkip) {
+        copyFolder(sourcePath, targetPath, replacements, gitignorePatterns);
+      }
+    } else {
+      copyFile(sourcePath, targetPath, replacements, gitignorePatterns);
+    }
+  });
+};
+
+const generateProject = (targetFolder: string, projectName?: string): void => {
+  // find template in published package
+  const templatePath = join(__dirname, '../templates/basic');
+  const gitignorePath = join(templatePath, '.gitignore');
+  
+  // Parse gitignore patterns
+  const gitignorePatterns = parseGitignore(gitignorePath);
+  
+  // Determine project name from folder or use placeholder
+  const folderName = projectName || basename(targetFolder === './' ? process.cwd() : targetFolder);
+  
+  // Get the current version of hardhat-deploy
+  const hardhatDeployVersion = getHardhatDeployVersion();
+  
+  const replacements: Record<string, string> = {
+    'template-hardhat-node-test-runner': `${folderName}`,
+    'workspace:*': hardhatDeployVersion,
+  };
+  
+  console.log(`Generating project in: ${targetFolder}`);
+  copyFolder(templatePath, targetFolder, replacements, gitignorePatterns);
+  console.log('✓ Project initialized successfully!');
+};
+
+const runPnpmInstall = async (folderPath: string): Promise<void> => {
+  console.log(`Installing dependencies...`);
+  const { spawn } = await import('child_process');
+  
+  return new Promise((resolve, reject) => {
+    // Use --ignore-workspace to ensure dependencies are installed locally
+    // This prevents pnpm from treating the target folder as part of a parent workspace
+    const pnpm = spawn('pnpm', ['install', '--ignore-workspace', `--no-frozen-lockfile`], {
+      cwd: folderPath,
+      stdio: 'inherit',
+    });
+
+    pnpm.on('close', (code) => {
+      if (code === 0) {
+        console.log('✓ Dependencies installed successfully!');
+        resolve();
+      } else {
+        reject(new Error(`pnpm install failed with exit code ${code}`));
+      }
+    });
+
+    pnpm.on('error', (error) => {
+      reject(error);
+    });
+  });
+};
+
+program
+  .name('hardhat-deploy')
+  .description('CLI for hardhat-deploy')
+  .version(pkg.version);
+
+program
+  .command('init')
+  .argument('[folder]', 'folder to initialize the project in')
+  .option('--install', 'auto-install dependencies with pnpm')
+  .description('Initialize a new hardhat-deploy project')
+  .action(async (folder?: string, options?: { install?: boolean }) => {
+    let targetFolder = folder;
+    let autoInstall = options?.install ?? false;
+    
+    // If no folder specified, ask user
+    if (!targetFolder) {
+      targetFolder = await askFolder();
+      // If we prompted for folder, also prompt for auto-install
+      autoInstall = await askAutoInstall();
+    }
+    
+    // Normalize path
+    targetFolder = targetFolder.trim();
+    
+    // Check if folder is empty
+    if (!isFolderEmpty(targetFolder)) {
+      console.error(`Error: Folder "${targetFolder}" is not empty. Please specify an empty folder or a new folder path.`);
+      process.exit(1);
+    }
+    
+    // Generate project
+    generateProject(targetFolder);
+    
+    // Auto-install if requested
+    if (autoInstall) {
+      try {
+        await runPnpmInstall(targetFolder);
+      } catch (error) {
+        console.error('Failed to install dependencies:', error);
+        console.log('\nYou can install dependencies manually:');
+        console.log(`  cd ${targetFolder === './' ? '.' : targetFolder}`);
+        console.log('  pnpm install');
+        process.exit(1);
+      }
+    }
+    
+    // Show next steps
+    console.log(`\nNext steps:`);
+    console.log(`  cd ${targetFolder === './' ? '.' : targetFolder}`);
+    if (!autoInstall) {
+      console.log(`  pnpm install`);
+    }
+    console.log(`  pnpm hardhat test`);
+  });
+
+program.parse();

package/src/config/default.ts

@@ -0,0 +1,6 @@
+import type {ArtifactGenerationConfig} from '../types.js';
+
+export const DEFAULT_CONFIG: ArtifactGenerationConfig = {
+	// externalArtifacts: [],
+	destinations: [{mode: 'javascript', folder: './generated'}],
+};

package/src/config/get-config.ts

@@ -0,0 +1,12 @@
+import type {ArtifactGenerationConfig, ArtifactGenerationUserConfig} from '../types.js';
+
+import {DEFAULT_CONFIG} from './default.js';
+
+export function getConfig(userConfig: ArtifactGenerationUserConfig | undefined): ArtifactGenerationConfig {
+	return {
+		destinations:
+			userConfig?.destinations?.map((v) => ({mode: v.mode || 'javascript', folder: v.folder || './generated'})) ||
+			DEFAULT_CONFIG.destinations,
+		// externalArtifacts: userConfig?.externalArtifacts || DEFAULT_CONFIG.externalArtifacts,
+	};
+}

package/src/config/validation.ts

@@ -0,0 +1,25 @@
+import type {HardhatUserConfigValidationError} from '@nomicfoundation/hardhat-zod-utils';
+import type {HardhatUserConfig} from 'hardhat/config';
+
+import {validateUserConfigZodType} from '@nomicfoundation/hardhat-zod-utils';
+import {z} from 'zod';
+
+const artifactGenerationUserConfigSchema = z
+	.object({
+		// externalArtifacts: z.array(z.string()).optional(),
+		destinations: z
+			.array(
+				z.object({
+					mode: z.union([z.literal('javascript'), z.literal('typescript')]).optional(),
+					folder: z.string().optional(),
+				})
+			)
+			.optional(),
+	})
+	.optional();
+
+export async function validateTypechainUserConfig(
+	userConfig: HardhatUserConfig
+): Promise<HardhatUserConfigValidationError[]> {
+	return validateUserConfigZodType(userConfig.generateTypedArtifacts, artifactGenerationUserConfigSchema);
+}

package/src/generate-types.ts

@@ -0,0 +1,281 @@
+import type {ArtifactGenerationConfig} from './types.js';
+import debug from 'debug';
+import fs from 'node:fs';
+import path, {basename, dirname} from 'node:path';
+import slash from 'slash';
+import {FileTraversed, traverse} from './utils/files.js';
+
+const log = debug('hardhat-deploy:generate-types');
+
+function writeIfDifferent(filePath: string, newTextContent: string) {
+	// Ensure we're working with a string
+	const contentToWrite = String(newTextContent);
+
+	try {
+		let existingContent;
+
+		try {
+			existingContent = fs.readFileSync(filePath, 'utf8');
+		} catch (error) {
+			// console.log(`do not exist? => writing ${filePath}`);
+			// File doesn't exist, write and return
+			fs.writeFileSync(filePath, contentToWrite);
+			return {written: true, reason: 'File did not exist'};
+		}
+
+		// Simple string comparison
+		if (contentToWrite !== existingContent) {
+			// console.log(`content different => writing ${filePath}`);
+			fs.writeFileSync(filePath, contentToWrite);
+			return {written: true, reason: 'Content was different'};
+		}
+
+		return {written: false, reason: 'Content was identical'};
+	} catch (error) {
+		console.error('Error in writeIfDifferent:', error);
+		throw error;
+	}
+}
+
+function ensureDirExistsSync(folderPath: string) {
+	// Check if directory already exists
+	if (fs.existsSync(folderPath)) {
+		return {created: false, reason: 'Directory already exists'};
+	}
+
+	// console.log(`do not exist? => mkdir ${folderPath}`);
+	// Directory doesn't exist, create it
+	fs.mkdirSync(folderPath, {recursive: true});
+	return {created: true, reason: 'Directory was created'};
+}
+
+type Artifact = {
+	contractName: string;
+	abi: any[];
+	// ...
+};
+
+type Artifacts = {[key: string]: Artifact};
+
+function writeArtifactToFile(folder: string, canonicalName: string, data: Artifact, mode: 'typescript' | 'javascript') {
+	const name = canonicalName.split('/').pop();
+	const artifactName = `Artifact_${name}`;
+	const tsFilepath = path.join(folder, 'artifacts', canonicalName) + '.ts';
+	const folderPath = path.dirname(tsFilepath);
+	ensureDirExistsSync(folderPath);
+	if (mode === 'typescript') {
+		const newContent = `export const ${artifactName}: ${JSON.stringify(data, null, 2)} = ${JSON.stringify(data, null, 2)} as const;`;
+		writeIfDifferent(tsFilepath, newContent);
+	} else if (mode === 'javascript') {
+		const newContent = `export const ${artifactName} = /** @type {const} **/ (${JSON.stringify(data, null, 2)});`;
+		const dtsContent = `export declare const ${artifactName}: ${JSON.stringify(data, null, 2)};`;
+		const jsFilepath = path.join(folder, 'artifacts', canonicalName) + '.js';
+		writeIfDifferent(jsFilepath, newContent);
+		writeIfDifferent(jsFilepath.replace(/\.js$/, '.d.ts'), dtsContent);
+	}
+}
+
+function writeArtifactIndexToFile(folder: string, data: Artifacts, mode: 'typescript' | 'javascript') {
+	const tsFilepath = path.join(folder, 'artifacts', 'index') + '.ts';
+	const folderPath = path.dirname(tsFilepath);
+	ensureDirExistsSync(folderPath);
+	if (mode === 'typescript') {
+		let newContent = '';
+		for (const canonicalName of Object.keys(data)) {
+			const transformedName = canonicalName.replaceAll('/', '_').replaceAll('.', '_');
+			const name = canonicalName.split('/').pop();
+			const artifactName = `Artifact_${name}`;
+			const importNaming =
+				canonicalName != name ? `${artifactName} as ${transformedName}` : `${artifactName} as ${name}`;
+			newContent += `export {${importNaming}} from './${canonicalName}.js';\n`;
+		}
+
+		writeIfDifferent(tsFilepath, newContent);
+	} else if (mode === 'javascript') {
+		let newContent = '';
+		for (const canonicalName of Object.keys(data)) {
+			const transformedName = canonicalName.replaceAll('/', '_').replaceAll('.', '_');
+			const name = canonicalName.split('/').pop();
+			const artifactName = `Artifact_${name}`;
+			const importNaming =
+				canonicalName != name ? `${artifactName} as ${transformedName}` : `${artifactName} as ${name}`;
+			newContent += `export {${importNaming}} from './${canonicalName}.js';\n`;
+		}
+		const jsFilepath = path.join(folder, 'artifacts', 'index') + '.js';
+		writeIfDifferent(jsFilepath, newContent);
+		writeIfDifferent(jsFilepath.replace(/\.js$/, '.d.ts'), newContent);
+	}
+}
+
+function writeABIDefinitionToFile(
+	folder: string,
+	canonicalName: string,
+	data: Artifact,
+	mode: 'typescript' | 'javascript',
+) {
+	const nameAsPath = canonicalName.split('/');
+	const name = nameAsPath[nameAsPath.length - 1];
+	const abiName = `Abi_${name}`;
+	const artifactName = `Artifact_${name}`;
+	const relativePath = `../`.repeat(nameAsPath.length);
+	const tsFilepath = path.join(folder, 'abis', canonicalName) + '.ts';
+	const folderPath = path.dirname(tsFilepath);
+	ensureDirExistsSync(folderPath);
+	if (mode === 'typescript') {
+		const newContent = `import {${artifactName}} from '${relativePath}artifacts/${canonicalName}.js';
+export type ${abiName} = (typeof ${artifactName})['abi'];\n`;
+		writeIfDifferent(tsFilepath, newContent);
+	} else if (mode === 'javascript') {
+		const jsFilepath = path.join(folder, 'abis', canonicalName) + '.js';
+		const newContent = `export {};\n`;
+		const dtsContent = `import {${artifactName}} from '${relativePath}artifacts/${canonicalName}.js';
+export type ${abiName} = (typeof ${artifactName})['abi'];\n`;
+		writeIfDifferent(jsFilepath, newContent);
+		writeIfDifferent(jsFilepath.replace(/\.js$/, '.d.ts'), dtsContent);
+	}
+}
+function writeABIDefinitionIndexToFile(folder: string, data: Artifacts, mode: 'typescript' | 'javascript') {
+	const tsFilepath = path.join(folder, 'abis', 'index') + '.ts';
+	const folderPath = path.dirname(tsFilepath);
+	ensureDirExistsSync(folderPath);
+	if (mode === 'typescript') {
+		let newContent = '';
+		for (const canonicalName of Object.keys(data)) {
+			const transformedName = canonicalName.replaceAll('/', '_').replaceAll('.', '_');
+			const name = canonicalName.split('/').pop();
+			const abiName = `Abi_${name}`;
+			const importNaming = canonicalName != name ? `${abiName} as ${transformedName}` : `${abiName} as ${name}`;
+			newContent += `export {${importNaming}} from "./${canonicalName}.js"\n`;
+		}
+		writeIfDifferent(tsFilepath, newContent);
+	} else if (mode === 'javascript') {
+		const jsFilepath = path.join(folder, 'abis', 'index') + '.js';
+		let newContent = '';
+		for (const canonicalName of Object.keys(data)) {
+			const transformedName = canonicalName.replaceAll('/', '_').replaceAll('.', '_');
+			const name = canonicalName.split('/').pop();
+			const abiName = `Abi_${name}`;
+			const importNaming = canonicalName != name ? `${abiName} as ${transformedName}` : `${abiName} as ${name}`;
+			newContent += `export {${importNaming}} from "./${canonicalName}.js"\n`;
+		}
+		writeIfDifferent(jsFilepath, newContent);
+		writeIfDifferent(jsFilepath.replace(/\.js$/, '.d.ts'), newContent);
+	}
+}
+
+export async function generateTypes(paths: {artifacts: string[]}, config: ArtifactGenerationConfig): Promise<void> {
+	const buildInfoCache = new Map<string, any>();
+	const allArtifacts: {[name: string]: any} = {};
+	const shortNameDict: {[shortName: string]: boolean} = {};
+
+	for (const artifactsPath of paths.artifacts) {
+		const files: FileTraversed[] = traverse(
+			artifactsPath,
+			[],
+			artifactsPath,
+			(name) => name != 'build-info' && !name.endsWith('.t.sol') && !name.endsWith('.dbg.json'),
+		);
+
+		// console.log('--------------------------');
+		// console.log(files);
+		// console.log('--------------------------');
+
+		for (const file of files) {
+			const filepath = file.path;
+			if (file.directory || !filepath.endsWith('.json')) {
+				continue;
+			}
+			const filename = slash(path.basename(filepath));
+			const dirname = slash(path.dirname(file.relativePath));
+
+			// const namePath = dirname.replace('.sol', '');
+			const contractName = filename.replace('.json', '');
+			// const shortName = artifact.artifactsEmitted[i];
+			// console.log({path: filepath});
+			const content = fs.readFileSync(filepath, 'utf-8');
+			const parsed = JSON.parse(content);
+
+			if (!parsed.buildInfoId) continue;
+
+			// TODO read config for artifacts folder
+			let buildInfoFilepath = path.join(artifactsPath, 'build-info', `${parsed.buildInfoId}.output.json`);
+
+			if (!parsed.buildInfoId) {
+				// support hardhat v2 artifacts files
+				if (fs.existsSync(filepath.replace('.json', '.dbg.json'))) {
+					// console.warn(`Artifact ${filepath} does not have a buildInfoId, but found a .dbg.json file. Using that instead.`);
+					const dbgContent = fs.readFileSync(filepath.replace('.json', '.dbg.json'), 'utf-8');
+					const dbgParsed = JSON.parse(dbgContent);
+					const buildInfoRelativePath = dbgParsed.buildInfo;
+					parsed.buildInfoId = path.basename(buildInfoRelativePath, '.json');
+					// console.log({buildInfoRelativePath, buildInfoId: parsed.buildInfoId});
+					buildInfoFilepath = path.join(artifactsPath, 'build-info', `${parsed.buildInfoId}.json`);
+				}
+			}
+
+			// const backupBuildInfoFilepath = path.join(
+			// 	'./generated',
+			// 	buildInfoFilepath.slice(buildInfoFilepath.indexOf('/', 1))
+			// );
+			let buildInfoFilepathToUse = buildInfoFilepath;
+			// if (!fs.existsSync(buildInfoFilepathToUse)) {
+			// 	buildInfoFilepathToUse = backupBuildInfoFilepath;
+			// }
+			let parsedBuildInfo;
+			if (!buildInfoCache.has(buildInfoFilepathToUse)) {
+				if (!fs.existsSync(buildInfoFilepathToUse)) continue;
+				const buildInfoContent = fs.readFileSync(buildInfoFilepathToUse, 'utf-8');
+				parsedBuildInfo = JSON.parse(buildInfoContent);
+				buildInfoCache.set(buildInfoFilepathToUse, parsedBuildInfo);
+			} else {
+				parsedBuildInfo = buildInfoCache.get(buildInfoFilepathToUse);
+			}
+
+			const solidityOutput = parsedBuildInfo.output.contracts[parsed.inputSourceName][contractName];
+			const hardhatArtifactObject = {...parsed, ...solidityOutput};
+			const {buildInfoId, _format, ...artifactObject} = hardhatArtifactObject;
+			const fullName = `${dirname}/${contractName}`;
+			allArtifacts[fullName] = artifactObject;
+			if (shortNameDict[contractName]) {
+				delete allArtifacts[contractName];
+			} else {
+				allArtifacts[contractName] = artifactObject;
+				shortNameDict[contractName] = true;
+			}
+		}
+	}
+
+	for (const key of Object.keys(allArtifacts)) {
+		if (key.indexOf('/') >= 0) {
+			const split = key.split('/');
+			if (split.length > 1) {
+				const shortName = split[split.length - 1];
+				if (allArtifacts[shortName]) {
+					delete allArtifacts[key];
+				}
+			}
+		}
+	}
+
+	// for (const key of Object.keys(allArtifacts)) {
+	// 	const artifact = allArtifacts[key];
+	// 	writeFiles(key, artifact, config);
+	// }
+	// // const json = hre.config.generateTypedArtifacts.json || [];
+	// // json.push('./generated/_artifacts.json');
+	// // writeFiles(undefined, allArtifacts, {...hre.config.generateTypedArtifacts, json: json});
+
+	// writeFiles(undefined, allArtifacts, config);
+
+	for (const destination of config.destinations) {
+		const generatedFolder = destination.folder;
+		const mode = destination.mode;
+		for (const key of Object.keys(allArtifacts)) {
+			writeABIDefinitionToFile(generatedFolder, key, allArtifacts[key], mode);
+			writeArtifactToFile(generatedFolder, key, allArtifacts[key], mode);
+		}
+
+		writeArtifactIndexToFile(generatedFolder, allArtifacts, mode);
+		writeABIDefinitionIndexToFile(generatedFolder, allArtifacts, mode);
+	}
+}