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

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

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

package/src/index.ts

@@ -0,0 +1,53 @@
+import {setupLogger} from 'named-logs-console';
+import type {HardhatPlugin} from 'hardhat/types/plugins';
+import {task} from 'hardhat/config';
+
+import './type-extensions.js';
+import {ArgumentType} from 'hardhat/types/arguments';
+import type {Environment} from 'rocketh/types';
+import type {NetworkConnection} from 'hardhat/types/network';
+
+// const deployTask = import.meta.resolve('./tasks/deploy.js').replace('.ts', '.js');
+// console.log({deployTask});
+
+setupLogger(['rocketh', '@rocketh/node'], {
+	enabled: true,
+	level: 3,
+});
+
+const hardhatPlugin: HardhatPlugin = {
+	id: 'hardhat-deploy',
+	hookHandlers: {
+		config: () => import('./hook-handlers/config.js'),
+		solidity: () => import('./hook-handlers/solidity.js'),
+	},
+	tasks: [
+		task('deploy', 'Deploy contracts')
+			// .addFlag('skipGasReport', 'if set, skip gas report')
+			.addFlag({name: 'skipPrompts', description: 'if set, skip any prompts'})
+			.addOption({
+				name: 'saveDeployments',
+				description: 'if set, save deployments',
+				defaultValue: '',
+				type: ArgumentType.STRING,
+			})
+			.addOption({
+				name: 'tags',
+				description: 'specify which tags to deploy',
+				defaultValue: '',
+				type: ArgumentType.STRING,
+			})
+			.setAction(() => import('./tasks/deploy.js'))
+			.build(),
+	],
+	npmPackage: 'hardhat-deploy',
+};
+
+export default hardhatPlugin;
+
+export function getHardhatConnection(env: Environment): NetworkConnection<'generic'> {
+	if (!env.extra?.connection) {
+		throw new Error('Hardhat deploy connection not found in the environment');
+	}
+	return env.extra.connection as NetworkConnection<'generic'>;
+}

package/src/postinstall.ts

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+
+// Attempt to detect if user is in a v1 environment
+// This script should be lightweight and fail gracefully
+
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { execSync } from 'child_process';
+
+
+const MIGRATION_URL = 'https://rocketh.dev/hardhat-deploy/documentation/how-to/migration-from-v1.html';
+const V1_INSTALL_CMD = 'npm install hardhat-deploy@1';
+const MARKER_FILE = '.hardhat-deploy-v2-notice';
+
+// Find the project root by navigating up from node_modules
+function findProjectRoot(currentPath: string): string {
+	let path = currentPath;
+	
+	while (path !== '/' && path !== '') {
+		// Check if we're inside node_modules
+		if (path.includes('node_modules')) {
+			path = dirname(path);
+			continue;
+		}
+		
+		// Check if this directory has a package.json (likely project root)
+		if (existsSync(join(path, 'package.json'))) {
+			return path;
+		}
+		
+		path = dirname(path);
+	}
+	
+	// Fallback to current directory
+	return currentPath;
+}
+
+async function checkEnvironment() {
+  // Postinstall runs in the package directory, need to find the actual project root
+  const projectRoot = findProjectRoot(process.cwd());
+  let v1Detected = false;
+  let reasons: string[] = [];
+
+  // Check for hardhat version via command line
+  try {
+    const output = execSync('hardhat --version', { encoding: 'utf-8', stdio: 'pipe', cwd: projectRoot });
+    // Output format is like "hardhat, version 2.x.x" or "hardhat, version 3.x.x"
+    const match = output.match(/hardhat, version (\d+\.\d+\.\d+)/);
+    if (match) {
+      const hardhatVersion = match[1];
+      if (hardhatVersion.startsWith('2.')) {
+        v1Detected = true;
+        reasons.push(`hardhat ${hardhatVersion} detected (v2 requires hardhat 3.x)`);
+      }
+    }
+  } catch (e) {
+    // Hardhat not installed yet - that's fine
+  }
+
+  // Check for v1-style config patterns
+  try {
+    const configFiles = ['hardhat.config.js', 'hardhat.config.ts'];
+
+    for (const configFile of configFiles) {
+      const configPath = join(projectRoot, configFile);
+      if (existsSync(configPath)) {
+        const content = readFileSync(configPath, 'utf-8');
+
+        if (content.includes('namedAccounts')) {
+          v1Detected = true;
+          reasons.push(`'namedAccounts' found in ${configFile}`);
+        }
+
+        if (content.includes("require('hardhat-deploy')") || content.includes('require("hardhat-deploy")')) {
+          v1Detected = true;
+          reasons.push(`require('hardhat-deploy') found in ${configFile}`);
+        }
+
+        if (content.includes('module.exports')) {
+          v1Detected = true;
+          reasons.push(`CommonJS 'module.exports' found in ${configFile}`);
+        }
+      }
+    }
+  } catch (e) {
+    // Config check failed - continue silently
+  }
+
+  if (v1Detected) {
+    printV1Warning(reasons);
+    createMarkerFile(projectRoot, reasons);
+  } else {
+    printWelcome();
+  }
+}
+
+function createMarkerFile(projectRoot: string, reasons: string[]) {
+  const markerPath = join(projectRoot, MARKER_FILE);
+  const content = `HARDHAT-DEPLOY V2 - V1 PATTERNS DETECTED
+
+This file was created because hardhat-deploy v2 detected v1 patterns in your project.
+You can delete this file after reading.
+
+Detected issues:
+${reasons.map((r) => `  - ${r}`).join('\n')}
+
+To resolve this, either:
+
+1. Install hardhat-deploy v1 instead:
+   npm uninstall hardhat-deploy
+   ${V1_INSTALL_CMD}
+
+2. Migrate your project to v2:
+   ${MIGRATION_URL}
+
+For more information, see the migration guide.
+`;
+
+  try {
+    writeFileSync(markerPath, content, 'utf-8');
+  } catch (e) {
+    // Failed to write marker file - continue anyway
+  }
+}
+
+function printV1Warning(reasons: string[]) {
+  const reasonsList = reasons.map((r) => `  • ${r}`).join('\n');
+
+  console.log(`
+╔══════════════════════════════════════════════════════════════════════════════╗
+║                                                                              ║
+║  ⚠️  HARDHAT-DEPLOY V2 - V1 PATTERNS DETECTED                                ║
+║                                                                              ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+
+Your project appears to be using hardhat-deploy v1 patterns:
+
+${reasonsList}
+
+hardhat-deploy v2 has MAJOR breaking changes and requires hardhat 3.x.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+OPTION 1: Install v1 instead (recommended for existing v1 projects)
+
+  npm uninstall hardhat-deploy
+  ${V1_INSTALL_CMD}
+
+OPTION 2: Migrate to v2
+
+  See: ${MIGRATION_URL}
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+A marker file '${MARKER_FILE}' has been created in your project root.
+`);
+}
+
+function printWelcome() {
+  console.log(`
+✓ hardhat-deploy v2 installed successfully!
+  Documentation: https://rocketh.dev/hardhat-deploy/
+`);
+}
+
+checkEnvironment().catch(() => {});

package/src/tasks/deploy.ts

@@ -0,0 +1,43 @@
+import {NewTaskActionFunction} from 'hardhat/types/tasks';
+import {loadAndExecuteDeploymentsFromFiles} from '@rocketh/node';
+import {generateForkConfig} from '../helpers.js';
+import {setupLogger} from 'named-logs-console';
+
+interface RunActionArguments {
+	saveDeployments: string;
+	skipPrompts: boolean;
+	tags?: string;
+}
+
+const runScriptWithHardhat: NewTaskActionFunction<RunActionArguments> = async (args, hre) => {
+	let saveDeployments = true;
+	let skipPrompts = args.skipPrompts ? true : false;
+
+	const {connection, environment, isFork, provider} = await generateForkConfig({hre});
+
+	const isMemoryNetwork = connection.networkConfig.type == 'edr-simulated';
+	if (isMemoryNetwork) {
+		skipPrompts = true;
+		saveDeployments = false;
+	}
+	if (args.saveDeployments != '') {
+		saveDeployments = args.saveDeployments == 'true' ? true : false;
+	}
+	const tags = args.tags && args.tags != '' ? args.tags : undefined;
+
+	setupLogger(['rocketh', '@rocketh/node'], {
+		enabled: true,
+		level: 3,
+	});
+
+	await loadAndExecuteDeploymentsFromFiles({
+		provider,
+		environment: environment,
+		saveDeployments: isFork ? false : saveDeployments,
+		askBeforeProceeding: skipPrompts ? false : true,
+		tags: tags?.split(','),
+		// reportGasUse: args.skipGasReport ? false : true,
+		extra: {connection},
+	});
+};
+export default runScriptWithHardhat;

package/src/type-extensions.ts

@@ -0,0 +1,12 @@
+import 'hardhat/types/config';
+import {ArtifactGenerationConfig, ArtifactGenerationUserConfig} from './types.js';
+
+declare module 'hardhat/types/config' {
+	export interface HardhatUserConfig {
+		generateTypedArtifacts?: ArtifactGenerationUserConfig;
+	}
+
+	export interface HardhatConfig {
+		readonly generateTypedArtifacts: ArtifactGenerationConfig;
+	}
+}