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

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

package/src/types.ts

@@ -0,0 +1,9 @@
+export type ArtifactGenerationUserConfig = {
+	// externalArtifacts?: string[];
+	destinations?: {mode?: 'javascript' | 'typescript'; folder?: string}[];
+};
+
+export type ArtifactGenerationConfig = {
+	// externalArtifacts: string[];
+	destinations: {mode: 'javascript' | 'typescript'; folder: string}[];
+};

package/src/utils/files.ts

@@ -0,0 +1,37 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export type FileTraversed = {
+	name: string;
+	path: string;
+	relativePath: string;
+	mtimeMs: number;
+	directory: boolean;
+};
+
+export function traverse(
+	dir: string,
+	result: any[] = [],
+	topDir?: string,
+	filter?: (name: string, stats: any) => boolean // TODO any is Stats
+): Array<FileTraversed> {
+	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;
+}

package/dist/esm/tasks/compile.d.ts

@@ -1,6 +0,0 @@
-import { NewTaskActionFunction } from 'hardhat/types/tasks';
-interface RunActionArguments {
-}
-declare const runScriptWithHardhat: NewTaskActionFunction<RunActionArguments>;
-export default runScriptWithHardhat;
-//# sourceMappingURL=compile.d.ts.map

package/dist/esm/tasks/compile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../src/tasks/compile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,qBAAqB,EAAC,MAAM,qBAAqB,CAAC;AAM1D,UAAU,kBAAkB;CAAG;AAmJ/B,QAAA,MAAM,oBAAoB,EAAE,qBAAqB,CAAC,kBAAkB,CA4InE,CAAC;AACF,eAAe,oBAAoB,CAAC"}