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

package/src/generate-types.ts

@@ -0,0 +1,278 @@
+import type {ArtifactGenerationConfig} from './types.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import {FileTraversed, slash, traverse} from './utils/files.js';
+
+
+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);
+	}
+}

package/src/helpers.ts

@@ -0,0 +1,311 @@
+import {configVariable} from 'hardhat/config';
+import {
+	EdrNetworkHDAccountsUserConfig,
+	EdrNetworkUserConfig,
+	HttpNetworkUserConfig,
+	NetworkUserConfig,
+	SensitiveString,
+} from 'hardhat/types/config';
+import {HardhatRuntimeEnvironment} from 'hardhat/types/hre';
+import {NetworkConnection} from 'hardhat/types/network';
+import type {Environment, UnresolvedUnknownNamedAccounts, UnresolvedNetworkSpecificData} from 'rocketh/types';
+import {enhanceEnvIfNeeded, chainByCanonicalName} from 'rocketh';
+import {loadEnvironmentFromFiles} from '@rocketh/node';
+
+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; connection?: NetworkConnection},
+		// options?: {
+		// 	useChainIdOfForkedNetwork?: boolean;
+		// }
+	) {
+		const env = await loadEnvironmentFromHardhat<NamedAccounts, Data>(required);
+		return enhanceEnvIfNeeded(env, extensions);
+	}
+
+	return {
+		loadEnvironmentFromHardhat: loadEnvironmentFromHardhatWithExtensions,
+	};
+}
+
+export async function generateForkConfig(
+	params: {hre: HardhatRuntimeEnvironment; connection?: NetworkConnection},
+	// options?: {
+	// 	useChainIdOfForkedNetwork?: boolean;
+	// }
+): Promise<{provider: any; environment: string | {fork: string}; connection: NetworkConnection; isFork: boolean}> {
+	const fork = process.env.HARDHAT_FORK as string | undefined;
+
+	const connection =
+		params.connection || fork
+			? await params.hre.network.connect({network: 'fork'})
+			: await params.hre.network.connect();
+
+	let provider: any = connection.provider;
+	let environment: string | {fork: string} = connection.networkName;
+	let forkChainId: number | undefined;
+
+	if (fork) {
+		// if (options?.useChainIdOfForkedNetwork) {
+		// 	const forkNetworkConfig = params.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`);
+		// 		}
+		// 	}
+		// }
+
+		environment = {
+			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];
+				}
+			},
+		});
+	}
+
+	return {provider, environment, connection, isFork: !!fork};
+}
+
+export async function loadEnvironmentFromHardhat<
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
+>(
+	params: {hre: HardhatRuntimeEnvironment; connection?: NetworkConnection},
+	// TODO ?
+	// options?: {
+	// 	useChainIdOfForkedNetwork?: boolean;
+	// }
+): Promise<Environment<NamedAccounts, Data>> {
+	const {connection, environment, provider, isFork} = await generateForkConfig(params);
+	// console.log(`loading environments...`);
+	return loadEnvironmentFromFiles<NamedAccounts, Data>({
+		provider,
+		environment,
+		extra: {
+			connection,
+		},
+		saveDeployments: isFork ? false : undefined,
+	});
+}
+
+function getVariable(prefix: string, name: string): string | SensitiveString | undefined {
+	// We transform dash into underscore as dash are not supported everywhere in env var names
+	const variableName = (prefix + name).replaceAll('-', '_');
+	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, doNotDefault?: boolean): string | SensitiveString | undefined {
+	if (networkName) {
+		const mnemonic = getVariable('MNEMONIC_', networkName);
+
+		if (mnemonic && mnemonic !== '') {
+			return mnemonic;
+		}
+	}
+
+	const mnemonic = process.env.MNEMONIC;
+	if (!mnemonic || mnemonic === '') {
+		if (doNotDefault) {
+			return undefined;
+		}
+		return 'test test test test test test test test test test test junk';
+	}
+	return mnemonic;
+}
+
+export function getAccounts(
+	networkName?: string,
+	doNotDefault?: boolean,
+): {mnemonic: string | SensitiveString} | undefined {
+	const mnemonic = getMnemonic(networkName, doNotDefault);
+	if (!mnemonic) {
+		return undefined;
+	}
+	return {mnemonic};
+}
+
+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;
+}
+
+const listOfNetworkNamesWithTestAccountAllowed = ['hardhat', 'localhost', 'memory', 'test'];
+export function addNetworksFromKnownList(
+	networks?: Record<string, NetworkUserConfig>,
+): Record<string, NetworkUserConfig> {
+	const newNetworks: Record<string, NetworkUserConfig> = networks ? {...networks} : {};
+	const canonicalNames = Object.keys(chainByCanonicalName);
+
+	for (const canonicalName of canonicalNames) {
+		const chain = chainByCanonicalName[canonicalName];
+		const url = getRPC(canonicalName) || chain.rpcUrls.default.http[0];
+		if (!newNetworks[canonicalName]) {
+			if (url) {
+				newNetworks[canonicalName] = {
+					type: 'http',
+					url,
+					accounts: getAccounts(canonicalName, !listOfNetworkNamesWithTestAccountAllowed.includes(canonicalName)),
+					chainType: chain.chainType === 'op-stack' ? 'op' : undefined,
+					chainId: chain.id,
+				};
+			} else {
+				console.error(`no url for chain ${canonicalName}`);
+			}
+		} else {
+			// console.error(`duplicated chain ${canonicalName}`);
+		}
+	}
+	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 existingForkConfiguration: EdrNetworkUserConfig =
+		networks.fork && networks.fork.type === 'edr-simulated' ? networks.fork : {type: 'edr-simulated', chainType: 'l1'};
+
+	const newNetworks: Record<string, NetworkUserConfig> = {
+		...networks,
+		fork: {
+			...existingForkConfiguration,
+			...{
+				accounts: hardhatAccounts || existingForkConfiguration?.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;
+};