hardhat-deploy 2.0.0-next.4 → 2.0.0-next.41

package/src/generate-types.ts

@@ -0,0 +1,292 @@
+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'};
+}
+
+function writeFiles(name: string | undefined, data: any, config: ArtifactGenerationConfig) {
+	const destinations = config.destinations;
+	const js = typeof destinations?.js === 'string' ? [destinations?.js] : destinations?.js || [];
+	const ts = typeof destinations?.ts === 'string' ? [destinations?.ts] : destinations?.ts || [];
+	const json = typeof destinations?.json === 'string' ? [destinations?.json] : destinations?.json || [];
+	const jsm = typeof destinations?.jsm === 'string' ? [destinations?.jsm] : destinations?.jsm || [];
+	const tsm = typeof destinations?.tsm === 'string' ? [destinations?.tsm] : destinations?.tsm || [];
+
+	if (ts.length > 0) {
+		const newContent = `export default ${JSON.stringify(data, null, 2)} as const;`;
+		for (const tsFile of ts) {
+			if (tsFile.endsWith('.ts')) {
+				if (!name) {
+					const filepath = tsFile;
+					const folderPath = path.dirname(filepath);
+					ensureDirExistsSync(folderPath);
+					writeIfDifferent(filepath, newContent);
+
+					ensureDirExistsSync(`${folderPath}/types`);
+					for (const name of Object.keys(data)) {
+						const splitted = name.split('/');
+						const numPath = splitted.length;
+						let pathToBase = '';
+						for (let i = 0; i < numPath; i++) {
+							pathToBase += '../';
+						}
+						let lastName = splitted.pop() || name;
+						const content = `
+import artifacts from '${pathToBase}${basename(tsFile.replace('.ts', '.js'))}';
+export type Abi_${lastName} = typeof artifacts["${name}"]["abi"];
+`;
+						ensureDirExistsSync(dirname(`${folderPath}/types/${name}`));
+						writeIfDifferent(`${folderPath}/types/${name}.ts`, content);
+					}
+				}
+			} else {
+				if (name) {
+					const filepath = `${tsFile}/${name}.ts`;
+					const folderPath = path.dirname(filepath);
+					ensureDirExistsSync(folderPath);
+					writeIfDifferent(filepath, newContent);
+				} else {
+					let indexFileContent = ``;
+
+					for (const name of Object.keys(data)) {
+						let transformedName = name.replaceAll('/', '_').replaceAll('.', '_');
+						indexFileContent += `
+import ${transformedName} from './${name}.js';
+export {${transformedName}};
+export type Abi_${transformedName} = typeof ${transformedName}.abi;
+`;
+					}
+					writeIfDifferent(`${tsFile}/index.ts`, indexFileContent);
+				}
+			}
+		}
+	}
+
+	if (js.length > 0) {
+		const newContent = `export default /** @type {const} **/ (${JSON.stringify(data, null, 2)});`;
+		// const dtsContent = `export = ${JSON.stringify(data, null, 2)} as const;`;
+		const dtsContent = `declare const _default: ${JSON.stringify(data, null, 2)};export default _default;`;
+		// const dtsContent = `declare const _default: ${JSON.stringify(data, null, 2)};export = _default;`;
+		const cjsContent = `module.exports = /** @type {const} **/ (${JSON.stringify(data, null, 2)});`;
+		for (const jsFile of js) {
+			if (jsFile.endsWith('.js')) {
+				if (!name) {
+					const filepath = jsFile;
+					const folderPath = path.dirname(filepath);
+					ensureDirExistsSync(folderPath);
+					writeIfDifferent(filepath, newContent);
+					writeIfDifferent(filepath.replace(/\.js$/, '.d.ts'), dtsContent);
+					writeIfDifferent(filepath.replace(/\.js$/, '.cjs'), cjsContent);
+				}
+			} else {
+				if (name) {
+					const filepath = `${jsFile}/${name}.js`;
+					const folderPath = path.dirname(filepath);
+					ensureDirExistsSync(folderPath);
+					writeIfDifferent(filepath, newContent);
+					writeIfDifferent(filepath.replace(/\.js$/, '.d.ts'), dtsContent);
+					writeIfDifferent(filepath.replace(/\.js$/, '.cjs'), cjsContent);
+				}
+			}
+		}
+	}
+
+	if (json.length > 0) {
+		const newContent = JSON.stringify(data, null, 2);
+		for (const jsonFile of json) {
+			if (jsonFile.endsWith('.json')) {
+				if (!name) {
+					const filepath = jsonFile;
+					const folderPath = path.dirname(filepath);
+					ensureDirExistsSync(folderPath);
+					writeIfDifferent(filepath, newContent);
+				}
+			} else {
+				if (name) {
+					const filepath = `${jsonFile}/${name}.json`;
+					const folderPath = path.dirname(filepath);
+					ensureDirExistsSync(folderPath);
+					writeIfDifferent(filepath, newContent);
+				}
+			}
+		}
+	}
+
+	if (!name) {
+		if (tsm.length > 0) {
+			let newContent = '';
+			for (const key of Object.keys(data)) {
+				newContent += `export const ${key} = ${JSON.stringify(data[key], null, 2)} as const;`;
+			}
+			for (const tsFile of tsm) {
+				const filepath = tsFile;
+				const folderPath = path.dirname(filepath);
+				ensureDirExistsSync(folderPath);
+				writeIfDifferent(filepath, newContent);
+			}
+		}
+
+		if (jsm.length > 0) {
+			let newContent = '';
+			for (const key of Object.keys(data)) {
+				newContent += `export const ${key} = /** @type {const} **/ (${JSON.stringify(data[key], null, 2)});`;
+			}
+			for (const jsFile of jsm) {
+				const filepath = jsFile;
+				const folderPath = path.dirname(filepath);
+				ensureDirExistsSync(folderPath);
+				writeIfDifferent(filepath, 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);
+}

package/src/helpers.ts

@@ -0,0 +1,285 @@
+import {configVariable} from 'hardhat/config';
+import {
+	EdrNetworkHDAccountsUserConfig,
+	EdrNetworkUserConfig,
+	HttpNetworkUserConfig,
+	NetworkUserConfig,
+	SensitiveString,
+} from 'hardhat/types/config';
+import {HardhatRuntimeEnvironment} from 'hardhat/types/hre';
+import {
+	Environment,
+	UnresolvedUnknownNamedAccounts,
+	UnresolvedNetworkSpecificData,
+	loadEnvironment,
+	enhanceEnvIfNeeded,
+} from 'rocketh';
+
+export function setupHardhatDeploy<
+	Extensions extends Record<string, (env: Environment<any, any, any>) => any> = {},
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData
+>(extensions: Extensions) {
+	async function loadEnvironmentFromHardhatWithExtensions(
+		required: {hre: HardhatRuntimeEnvironment},
+		options?: {
+			useChainIdOfForkedNetwork?: boolean;
+		}
+	) {
+		const env = await loadEnvironmentFromHardhat<NamedAccounts, Data>(required, options);
+		return enhanceEnvIfNeeded(env, extensions);
+	}
+
+	return {
+		loadEnvironmentFromHardhat: loadEnvironmentFromHardhatWithExtensions,
+	};
+}
+
+export async function loadEnvironmentFromHardhat<
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData
+>(
+	{hre}: {hre: HardhatRuntimeEnvironment},
+	options?: {
+		useChainIdOfForkedNetwork?: boolean;
+	}
+): Promise<Environment<NamedAccounts, Data>> {
+	const connection = await hre.network.connect();
+	let provider: any = connection.provider;
+	let network: string | {fork: string} = connection.networkName;
+	let forkChainId: number | undefined;
+	const fork = process.env.HARDHAT_FORK as string | undefined;
+	if (fork) {
+		if (options?.useChainIdOfForkedNetwork) {
+			const forkNetworkConfig = hre.config.networks[fork];
+
+			if (forkNetworkConfig.type === 'edr-simulated') {
+				forkChainId = forkNetworkConfig.chainId;
+			} else if (forkNetworkConfig.chainId) {
+				forkChainId = forkNetworkConfig.chainId;
+			} else {
+				if ('url' in forkNetworkConfig) {
+					const url = await forkNetworkConfig.url.getUrl();
+					const response = await fetch(url, {
+						method: 'POST',
+						headers: {
+							'Content-Type': 'application/json',
+						},
+						body: JSON.stringify({
+							jsonrpc: '2.0',
+							id: 1,
+							method: 'eth_chainId',
+							params: [],
+						}),
+					});
+					const json = (await response.json()) as {result: string};
+					forkChainId = Number(json.result);
+				} else {
+					throw new Error(`cannot fetch chainId`);
+				}
+			}
+		}
+
+		network = {
+			fork,
+		};
+	}
+
+	if (forkChainId) {
+		const originalProvider = provider;
+		const chainId = forkChainId;
+		async function request(args: {method: string; params?: string[]}): Promise<any> {
+			if (args.method === 'eth_chainId') {
+				return `0x${chainId.toString(16)}`;
+			}
+			return originalProvider.request(args);
+		}
+		provider = new Proxy(originalProvider, {
+			get: function (target, property, receiver) {
+				switch (property) {
+					case 'request':
+						return request;
+					default:
+						return originalProvider[property];
+				}
+			},
+		});
+	}
+
+	// console.log(`loading environments...`);
+	return loadEnvironment<NamedAccounts, Data>({
+		provider,
+		network,
+		extra: {
+			connection,
+		},
+	});
+}
+
+function getVariable(prefix: string, name: string): string | SensitiveString | undefined {
+	const variableName = prefix + name;
+	let uri = process.env[variableName];
+	if (uri === 'SECRET') {
+		return configVariable(`SECRET_${variableName}`);
+	} else if (uri?.startsWith('SECRET:')) {
+		const splitted = uri.split(':');
+		if (splitted.length !== 2) {
+			throw new Error(`invalid secret uri ${uri}`);
+		}
+		return configVariable(`SECRET_${prefix + splitted[1]}`);
+	}
+	return uri;
+}
+
+export function getRPC(networkName: string): string | SensitiveString | undefined {
+	let uri = getVariable('ETH_NODE_URI_', networkName);
+
+	if (uri && uri !== '') {
+		return uri;
+	}
+
+	uri = process.env.ETH_NODE_URI;
+	if (uri) {
+		uri = uri.replace('{{networkName}}', networkName);
+	}
+	if (!uri || uri === '') {
+		if (networkName === 'localhost') {
+			return 'http://localhost:8545';
+		}
+		return uri;
+		// throw new Error(`no uri specified or for network ${networkName}`);
+	}
+	if (uri.indexOf('{{') >= 0) {
+		throw new Error(`invalid uri or network not supported by node provider : ${uri}`);
+	}
+
+	return uri;
+}
+
+export function getMnemonic(networkName?: string): string | SensitiveString {
+	if (networkName) {
+		const mnemonic = getVariable('MNEMONIC_', networkName);
+
+		if (mnemonic && mnemonic !== '') {
+			return mnemonic;
+		}
+	}
+
+	const mnemonic = process.env.MNEMONIC;
+	if (!mnemonic || mnemonic === '') {
+		return 'test test test test test test test test test test test junk';
+	}
+	return mnemonic;
+}
+
+export function getAccounts(networkName?: string): {mnemonic: string | SensitiveString} {
+	return {mnemonic: getMnemonic(networkName)};
+}
+
+export function addNetworksFromEnv(networks?: Record<string, NetworkUserConfig>): Record<string, NetworkUserConfig> {
+	const newNetworks: Record<string, NetworkUserConfig> = networks ? {...networks} : {};
+	const allEnv = Object.keys(process.env);
+	for (const envKey of allEnv) {
+		if (envKey.startsWith(`ETH_NODE_URI_`) && envKey.length > `ETH_NODE_URI_`.length) {
+			const networkName = envKey.slice(`ETH_NODE_URI_`.length);
+			const url = getRPC(networkName);
+			if (!newNetworks[networkName]) {
+				if (url) {
+					newNetworks[networkName] = {
+						type: 'http',
+						url,
+						accounts: getAccounts(networkName),
+					};
+				} else {
+					console.error(`no url for network ${networkName}`);
+				}
+			} else {
+				console.error(`duplicated network ${networkName}`);
+			}
+		}
+	}
+	return newNetworks;
+}
+
+export function populateNetworksFromEnv(
+	networks: Record<string, Omit<NetworkUserConfig, 'accounts' | 'url'> | EdrNetworkUserConfig>
+): Record<string, NetworkUserConfig> {
+	const newNetworks: Record<string, NetworkUserConfig> = {};
+	for (const networkName of Object.keys(networks)) {
+		const network = networks[networkName];
+		if (network.type === 'edr-simulated') {
+			// we leave memory network alone
+			newNetworks[networkName] = network as EdrNetworkUserConfig;
+		} else {
+			const url = getRPC(networkName);
+			if (url) {
+				newNetworks[networkName] = {
+					...network,
+					url,
+					accounts: getAccounts(networkName),
+				};
+			} else {
+				if (!('url' in network) || !network.url) {
+					console.error(`no url for network ${networkName}`);
+				}
+			}
+		}
+	}
+	return newNetworks;
+}
+
+export function addForkConfiguration(networks: Record<string, NetworkUserConfig>): Record<string, NetworkUserConfig> {
+	const currentNetworkName = process.env.HARDHAT_FORK;
+	let forkURL: SensitiveString | string | undefined;
+	let hardhatAccounts: EdrNetworkHDAccountsUserConfig | undefined;
+	if (
+		currentNetworkName &&
+		currentNetworkName !== 'hardhat' &&
+		currentNetworkName !== 'edr' &&
+		currentNetworkName !== 'edr-simulated' &&
+		currentNetworkName !== 'memory'
+	) {
+		const currentNetwork = networks[currentNetworkName] as HttpNetworkUserConfig;
+		if (currentNetwork) {
+			if (currentNetwork.type === 'http') {
+				forkURL = currentNetwork.url;
+				if (
+					currentNetwork.accounts &&
+					typeof currentNetwork.accounts === 'object' &&
+					'mnemonic' in currentNetwork.accounts
+				) {
+					hardhatAccounts = currentNetwork.accounts;
+				}
+
+				// else if (currentNetwork.accounts && Array.isArray(currentNetwork.accounts)) {
+				// 	hardhatAccounts = currentNetwork.accounts.map((v) => ({
+				// 		balance: '10000000000000000000000',
+				// 		privateKey: v,
+				// 	}));
+				// }
+			}
+		}
+	}
+
+	const existingHardhat: EdrNetworkUserConfig =
+		networks.hardhat && networks.hardhat.type === 'edr-simulated'
+			? networks.hardhat
+			: {type: 'edr-simulated', chainType: 'l1'};
+
+	const newNetworks: Record<string, NetworkUserConfig> = {
+		...populateNetworksFromEnv(networks),
+		hardhat: {
+			...existingHardhat,
+			...{
+				accounts: hardhatAccounts || existingHardhat?.accounts,
+				forking: forkURL
+					? {
+							url: forkURL,
+							blockNumber: process.env.HARDHAT_FORK_NUMBER ? parseInt(process.env.HARDHAT_FORK_NUMBER) : undefined,
+					  }
+					: undefined,
+			},
+		},
+	};
+	return newNetworks;
+}

package/src/hook-handlers/config.ts

@@ -0,0 +1,80 @@
+import type {ConfigHooks} from 'hardhat/types/hooks';
+
+import {getConfig} from '../config/get-config.js';
+import {validateTypechainUserConfig} from '../config/validation.js';
+import {SolidityBuildProfileConfig, SolidityConfig} from 'hardhat/types/config';
+
+function addIfNotPresent(array: string[], value: string) {
+	if (array.indexOf(value) === -1) {
+		array.push(value);
+	}
+}
+function setupExtraSolcSettings(settings: {
+	metadata: {useLiteralContent: boolean};
+	outputSelection: {'*': {'': string[]; '*': string[]}};
+}): void {
+	settings.metadata = settings.metadata || {};
+	settings.metadata.useLiteralContent = true;
+
+	if (settings.outputSelection === undefined) {
+		settings.outputSelection = {
+			'*': {
+				'*': [],
+				'': [],
+			},
+		};
+	}
+	if (settings.outputSelection['*'] === undefined) {
+		settings.outputSelection['*'] = {
+			'*': [],
+			'': [],
+		};
+	}
+	if (settings.outputSelection['*']['*'] === undefined) {
+		settings.outputSelection['*']['*'] = [];
+	}
+	if (settings.outputSelection['*'][''] === undefined) {
+		settings.outputSelection['*'][''] = [];
+	}
+
+	addIfNotPresent(settings.outputSelection['*']['*'], 'abi');
+	// addIfNotPresent(settings.outputSelection['*']['*'], 'evm.bytecode');
+	// addIfNotPresent(settings.outputSelection['*']['*'], 'evm.deployedBytecode');
+	addIfNotPresent(settings.outputSelection['*']['*'], 'metadata');
+	addIfNotPresent(settings.outputSelection['*']['*'], 'devdoc');
+	addIfNotPresent(settings.outputSelection['*']['*'], 'userdoc');
+	addIfNotPresent(settings.outputSelection['*']['*'], 'storageLayout');
+	// addIfNotPresent(settings.outputSelection['*']['*'], 'evm.methodIdentifiers');
+	addIfNotPresent(settings.outputSelection['*']['*'], 'evm.gasEstimates');
+	// addIfNotPresent(settings.outputSelection["*"][""], "ir");
+	// addIfNotPresent(settings.outputSelection["*"][""], "irOptimized");
+	// addIfNotPresent(settings.outputSelection["*"][""], "ast");
+}
+
+export default async (): Promise<Partial<ConfigHooks>> => {
+	const handlers: Partial<ConfigHooks> = {
+		validateUserConfig: validateTypechainUserConfig,
+		resolveUserConfig: async (userConfig, resolveConfigurationVariable, next) => {
+			const resolvedConfig = await next(userConfig, resolveConfigurationVariable);
+
+			const solidity: SolidityConfig = structuredClone(resolvedConfig.solidity);
+			const profiles: Record<string, SolidityBuildProfileConfig> = solidity.profiles;
+			for (const profileName of Object.keys(profiles)) {
+				const profile: SolidityBuildProfileConfig = profiles[profileName];
+				const compilers = profile.compilers;
+				for (const compiler of compilers) {
+					const settings = compiler.settings;
+					setupExtraSolcSettings(settings);
+				}
+			}
+
+			return {
+				...resolvedConfig,
+				solidity,
+				generateTypedArtifacts: getConfig(userConfig.generateTypedArtifacts),
+			};
+		},
+	};
+
+	return handlers;
+};

package/src/hook-handlers/solidity.ts

@@ -0,0 +1,33 @@
+import type {HookContext, SolidityHooks} from 'hardhat/types/hooks';
+
+import {generateTypes} from '../generate-types.js';
+
+export default async (): Promise<Partial<SolidityHooks>> => {
+	const handlers: Partial<SolidityHooks> = {
+		async onCleanUpArtifacts(
+			context: HookContext,
+			artifactPaths: string[],
+			next: (nextContext: HookContext, artifactPaths: string[]) => Promise<void>
+		) {
+			let artifactPathsToProcess = [context.config.paths.artifacts];
+			// if (context.config.generateTypedArtifacts.externalArtifacts) {
+			// 	artifactPathsToProcess = artifactPathsToProcess.concat(
+			// 		context.config.generateTypedArtifacts.externalArtifacts
+			// 	);
+			// }
+
+			if (artifactPaths.length > 0) {
+				await generateTypes(
+					{
+						artifacts: artifactPathsToProcess,
+					},
+					context.config.generateTypedArtifacts
+				);
+			}
+
+			return next(context, artifactPaths);
+		},
+	};
+
+	return handlers;
+};