hardhat-deploy 2.0.0-next.6 → 2.0.0-next.61

package/dist/esm/type-extensions.d.ts

@@ -2,10 +2,10 @@ import 'hardhat/types/config';
 import { ArtifactGenerationConfig, ArtifactGenerationUserConfig } from './types.js';
 declare module 'hardhat/types/config' {
     interface HardhatUserConfig {
-        generateArtifacts?: ArtifactGenerationUserConfig;
+        generateTypedArtifacts?: ArtifactGenerationUserConfig;
     }
     interface HardhatConfig {
-        readonly generateArtifacts: ArtifactGenerationConfig;
+        readonly generateTypedArtifacts: ArtifactGenerationConfig;
     }
 }
 //# sourceMappingURL=type-extensions.d.ts.map

package/dist/esm/type-extensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type-extensions.d.ts","sourceRoot":"","sources":["../../src/type-extensions.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,EAAC,wBAAwB,EAAE,4BAA4B,EAAC,MAAM,YAAY,CAAC;AAElF,OAAO,QAAQ,sBAAsB,CAAC;IACrC,UAAiB,iBAAiB;QACjC,iBAAiB,CAAC,EAAE,4BAA4B,CAAC;KACjD;IAED,UAAiB,aAAa;QAC7B,QAAQ,CAAC,iBAAiB,EAAE,wBAAwB,CAAC;KACrD;CACD"}
+{"version":3,"file":"type-extensions.d.ts","sourceRoot":"","sources":["../../src/type-extensions.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,EAAC,wBAAwB,EAAE,4BAA4B,EAAC,MAAM,YAAY,CAAC;AAElF,OAAO,QAAQ,sBAAsB,CAAC;IACrC,UAAiB,iBAAiB;QACjC,sBAAsB,CAAC,EAAE,4BAA4B,CAAC;KACtD;IAED,UAAiB,aAAa;QAC7B,QAAQ,CAAC,sBAAsB,EAAE,wBAAwB,CAAC;KAC1D;CACD"}

package/dist/esm/types.d.ts

@@ -1,15 +1,13 @@
 export type ArtifactGenerationUserConfig = {
-    js?: string[];
-    ts?: string[];
-    json?: string[];
-    jsm?: string[];
-    tsm?: string[];
+    destinations?: {
+        mode?: 'javascript' | 'typescript';
+        folder?: string;
+    }[];
 };
 export type ArtifactGenerationConfig = {
-    js: string[];
-    ts: string[];
-    json: string[];
-    jsm: string[];
-    tsm: string[];
+    destinations: {
+        mode: 'javascript' | 'typescript';
+        folder: string;
+    }[];
 };
 //# sourceMappingURL=types.d.ts.map

package/dist/esm/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,4BAA4B,GAAG;IAC1C,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACtC,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,GAAG,EAAE,MAAM,EAAE,CAAC;CACd,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,4BAA4B,GAAG;IAE1C,YAAY,CAAC,EAAE;QAAC,IAAI,CAAC,EAAE,YAAY,GAAG,YAAY,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAC,EAAE,CAAC;CACvE,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IAEtC,YAAY,EAAE;QAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,EAAE,CAAC;CACpE,CAAC"}

package/dist/esm/utils/files.d.ts

@@ -0,0 +1,9 @@
+export type FileTraversed = {
+    name: string;
+    path: string;
+    relativePath: string;
+    mtimeMs: number;
+    directory: boolean;
+};
+export declare function traverse(dir: string, result?: any[], topDir?: string, filter?: (name: string, stats: any) => boolean): Array<FileTraversed>;
+//# sourceMappingURL=files.d.ts.map

package/dist/esm/utils/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../../src/utils/files.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,wBAAgB,QAAQ,CACvB,GAAG,EAAE,MAAM,EACX,MAAM,GAAE,GAAG,EAAO,EAClB,MAAM,CAAC,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,OAAO,GAC5C,KAAK,CAAC,aAAa,CAAC,CAoBtB"}

package/dist/esm/utils/files.js

@@ -0,0 +1,25 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function traverse(dir, result = [], topDir, filter // TODO any is Stats
+) {
+    fs.readdirSync(dir).forEach((name) => {
+        const fPath = path.resolve(dir, name);
+        const stats = fs.statSync(fPath);
+        if ((!filter && !name.startsWith('.')) || (filter && filter(name, stats))) {
+            const fileStats = {
+                name,
+                path: fPath,
+                relativePath: path.relative(topDir || dir, fPath),
+                mtimeMs: stats.mtimeMs,
+                directory: stats.isDirectory(),
+            };
+            if (fileStats.directory) {
+                result.push(fileStats);
+                return traverse(fPath, result, topDir || dir, filter);
+            }
+            result.push(fileStats);
+        }
+    });
+    return result;
+}
+//# sourceMappingURL=files.js.map

package/dist/esm/utils/files.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.js","sourceRoot":"","sources":["../../../src/utils/files.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,IAAI,MAAM,WAAW,CAAC;AAU7B,MAAM,UAAU,QAAQ,CACvB,GAAW,EACX,SAAgB,EAAE,EAClB,MAAe,EACf,MAA8C,CAAC,oBAAoB;;IAEnE,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QACpC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACtC,MAAM,KAAK,GAAG,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC;YAC3E,MAAM,SAAS,GAAG;gBACjB,IAAI;gBACJ,IAAI,EAAE,KAAK;gBACX,YAAY,EAAE,IAAI,CAAC,QAAQ,CAAC,MAAM,IAAI,GAAG,EAAE,KAAK,CAAC;gBACjD,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,SAAS,EAAE,KAAK,CAAC,WAAW,EAAE;aAC9B,CAAC;YACF,IAAI,SAAS,CAAC,SAAS,EAAE,CAAC;gBACzB,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;gBACvB,OAAO,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,IAAI,GAAG,EAAE,MAAM,CAAC,CAAC;YACvD,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACxB,CAAC;IACF,CAAC,CAAC,CAAC;IACH,OAAO,MAAM,CAAC;AACf,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hardhat-deploy",
-  "version": "2.0.0-next.6",
+  "version": "2.0.0-next.61",
   "description": "deployment plugin for hardhat",
   "publishConfig": {
     "access": "public"
@@ -24,26 +24,31 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "devDependencies": {
-    "@types/node": "^20.14.8",
+    "@changesets/cli": "^2.29.8",
+    "@rocketh/node": "0.17.15",
+    "@types/node": "^25.0.6",
     "as-soon": "^0.0.11",
-    "hardhat": "^3.0.0-next.1",
-    "rimraf": "^5.0.7",
-    "typescript": "^5.5.2",
-    "rocketh": "1.0.0-next.1"
+    "hardhat": "3.1.3",
+    "rimraf": "^6.1.2",
+    "rocketh": "0.17.12",
+    "set-defaults": "^0.0.5",
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "hardhat": "^3.0.0-next.1",
-    "rocketh": "1.0.0-next.1"
+    "@rocketh/node": "^0.17.15",
+    "hardhat": "^3.1.3"
   },
   "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"
+    "debug": "^4.4.3",
+    "named-logs-console": "^0.5.1",
+    "slash": "^5.1.0",
+    "zod": "^3.25.76"
   },
   "scripts": {
     "build": "tsc --project tsconfig.json",

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);
+	}
+}