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

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

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,59 @@
+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;
+}
+
+// from https://github.com/sindresorhus/slash
+/*
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+export function slash(path: string) {
+	const isExtendedLengthPath = path.startsWith('\\\\?\\');
+
+	if (isExtendedLengthPath) {
+		return path;
+	}
+
+	return path.replace(/\\/g, '/');
+}

package/src/v1-entry.cjs

@@ -0,0 +1,92 @@
+// This file serves as a CommonJS entry point for hardhat v2
+// It detects v1 users and shows them a migration message
+
+const MIGRATION_URL = 'https://rocketh.dev/hardhat-deploy/documentation/how-to/migration-from-v1.html';
+const V1_INSTALL_CMD = 'npm install hardhat-deploy@1';
+
+function getHardhatVersion() {
+	try {
+		const {execSync} = require('child_process');
+		// Run hardhat --version to get the version
+		const output = execSync('hardhat --version', {encoding: 'utf-8', stdio: 'pipe'});
+		return output.trim();
+	} catch (e) {
+		console.error(e);
+		return 'unknown';
+	}
+}
+
+function detectV1Patterns() {
+	const fs = require('fs');
+	const path = require('path');
+	const reasons = [];
+
+	// Check hardhat.config for v1 patterns
+	const configFiles = ['hardhat.config.js', 'hardhat.config.cjs', 'hardhat.config.ts'];
+
+	for (const configFile of configFiles) {
+		const configPath = path.join(process.cwd(), configFile);
+		if (fs.existsSync(configPath)) {
+			try {
+				const content = fs.readFileSync(configPath, 'utf-8');
+
+				if (content.includes('namedAccounts')) {
+					reasons.push(`Found 'namedAccounts' in ${configFile} - this is a v1 pattern`);
+				}
+
+				if (content.includes("require('hardhat-deploy')") || content.includes('require("hardhat-deploy")')) {
+					reasons.push(
+						`Found require('hardhat-deploy') in ${configFile} - v2 uses ESM: import HardhatDeploy from 'hardhat-deploy'`,
+					);
+				}
+
+				if (content.includes('module.exports')) {
+					reasons.push(`Found 'module.exports' in ${configFile} - v2 uses ESM: export default defineConfig({...})`);
+				}
+			} catch (e) {
+				// Failed to read config - continue
+			}
+		}
+	}
+
+	return reasons;
+}
+
+function throwV1Error() {
+	const hardhatVersion = getHardhatVersion();
+	const reasons = detectV1Patterns();
+
+	let reasonsList = '';
+	if (reasons.length > 0) {
+		reasonsList = '\nYour project uses hardhat-deploy v1 patterns:\n\n' + reasons.map((r) => `  • ${r}`).join('\n');
+	}
+
+	throw new Error(`
+╔══════════════════════════════════════════════════════════════════════════════╗
+║  HARDHAT-DEPLOY V2 - INCOMPATIBLE WITH HARDHAT V2                            ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+
+hardhat-deploy v2 requires hardhat 3.x, but you are using hardhat ${hardhatVersion}.${reasonsList}
+
+hardhat-deploy v2 has MAJOR breaking changes and uses ESM modules.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+OPTION 1: Install hardhat-deploy v1 (recommended for hardhat v2 projects)
+
+  npm uninstall hardhat-deploy
+  ${V1_INSTALL_CMD}
+
+OPTION 2: Upgrade to hardhat 3.x and hardhat-deploy v2
+
+  Migration guide: ${MIGRATION_URL}
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+}
+
+// Throw error immediately when loaded by hardhat v2
+throwV1Error();
+
+// Export a dummy function to satisfy hardhat's plugin loading
+module.exports = function () {};

package/templates/basic/README.md

@@ -0,0 +1,44 @@
+# Sample Hardhat 3 Project (`node:test`)
+
+This project showcases a Hardhat 3 project using the [hardhat-deploy](https://github.com/wighawag/hardhat-deploy) plugin (along with the [rocketh](https://github.com/wighawag/rocketh) deployment system) and the native Node.js test runner (`node:test`) .
+
+To learn more about hardhat-deploy and rocketh, please visit the [documentation](https://rocketh.dev).
+
+## Project Overview
+
+This example project includes:
+
+- A simple Hardhat configuration file.
+- Foundry-compatible Solidity unit tests.
+- Built-in mechanism to load deployments in test via hardhat-deploy and rocketh.
+
+## Usage
+
+### Running Tests
+
+To run all the tests in the project, execute the following command:
+
+```bash
+pnpm hardhat test
+```
+
+You can also selectively run the Solidity or `node:test` tests:
+
+```bash
+pnpm hardhat test solidity
+pnpm hardhat test nodejs
+```
+
+### Deploying Contracts
+
+To deploy the contracts to an in-memory network, run:
+
+```bash
+pnpm hardhat deploy
+```
+
+To deploy the contracts to a specific network, use the `--network` option:
+
+```bash
+pnpm hardhat deploy --network <network-name>
+```

package/templates/basic/contracts/Counter.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.28;
+
+contract Counter {
+  uint public x;
+
+  event Increment(uint by);
+
+  function inc() public {
+    x++;
+    emit Increment(1);
+  }
+
+  function incBy(uint by) public {
+    require(by > 0, "incBy: increment should be positive");
+    x += by;
+    emit Increment(by);
+  }
+}

package/templates/basic/contracts/Counter.t.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.28;
+
+import {Counter} from "./Counter.sol";
+import {Test} from "forge-std/Test.sol";
+
+contract CounterTest is Test {
+  Counter counter;
+
+  function setUp() public {
+    counter = new Counter();
+  }
+
+  function test_InitialValue() public view {
+    require(counter.x() == 0, "Initial value should be 0");
+  }
+
+  function testFuzz_Inc(uint8 x) public {
+    for (uint8 i = 0; i < x; i++) {
+      counter.inc();
+    }
+    require(counter.x() == x, "Value after calling inc x times should be x");
+  }
+
+  function test_IncByZero() public {
+    vm.expectRevert();
+    counter.incBy(0);
+  }
+}

package/templates/basic/deploy/01_deploy_counter.ts

@@ -0,0 +1,13 @@
+import { deployScript, artifacts } from "../rocketh/deploy.js";
+
+export default deployScript(
+  async ({ deploy, namedAccounts }) => {
+    const { deployer } = namedAccounts;
+
+    await deploy("Counter", {
+      account: deployer,
+      artifact: artifacts.Counter,
+    });
+  },
+  { tags: ["Counter", "Counter_deploy"] },
+);

package/templates/basic/hardhat.config.ts

@@ -0,0 +1,50 @@
+import { configVariable, defineConfig } from "hardhat/config";
+import hardhatNodeTestRunnerPlugin from "@nomicfoundation/hardhat-node-test-runner";
+import hardhatKeyStorePlugin from "@nomicfoundation/hardhat-keystore";
+import hardhatNetworkHelpersPlugin from "@nomicfoundation/hardhat-network-helpers";
+import hardhatViemPlugin from "@nomicfoundation/hardhat-viem";
+import hardhatViemAssertionsPlugin from "@nomicfoundation/hardhat-viem-assertions";
+import HardhatDeploy from "hardhat-deploy";
+
+export default defineConfig({
+  plugins: [
+    hardhatNodeTestRunnerPlugin,
+    hardhatKeyStorePlugin,
+    hardhatNetworkHelpersPlugin,
+    HardhatDeploy,
+    hardhatViemPlugin,
+    hardhatViemAssertionsPlugin
+  ],
+  solidity: {
+    profiles: {
+      default: {
+        version: "0.8.28",
+      },
+      production: {
+        version: "0.8.28",
+        settings: {
+          optimizer: {
+            enabled: true,
+            runs: 200,
+          },
+        },
+      },
+    },
+  },
+  networks: {
+    hardhatMainnet: {
+      type: "edr-simulated",
+      chainType: "l1",
+    },
+    hardhatOp: {
+      type: "edr-simulated",
+      chainType: "op",
+    },
+    sepolia: {
+      type: "http",
+      chainType: "l1",
+      url: configVariable("SEPOLIA_RPC_URL"),
+      accounts: [configVariable("SEPOLIA_PRIVATE_KEY")],
+    },
+  },
+});

package/templates/basic/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "template-hardhat-node-test-runner",
+  "version": "0.0.0",
+  "description": "A TypeScript Hardhat project using Node Test Runner",
+  "type": "module",
+  "devDependencies": {
+    "@nomicfoundation/hardhat-keystore": "^3.0.3",
+    "@nomicfoundation/hardhat-network-helpers": "^3.0.3",
+    "@nomicfoundation/hardhat-node-test-runner": "^3.0.8",
+    "@nomicfoundation/hardhat-viem": "^3.0.2",
+    "@nomicfoundation/hardhat-viem-assertions": "^3.0.5",
+    "@rocketh/deploy": "^0.17.9",
+    "@rocketh/doc": "^0.17.18",
+    "@rocketh/export": "^0.17.18",
+    "@rocketh/node": "^0.17.18",
+    "@rocketh/proxy": "^0.17.13",
+    "@rocketh/read-execute": "^0.17.9",
+    "@rocketh/verifier": "^0.17.18",
+    "@rocketh/viem": "^0.17.6",
+    "@types/node": "^25.0.10",
+    "forge-std": "foundry-rs/forge-std#v1.9.4",
+    "hardhat": "^3.1.5",
+    "hardhat-deploy": "workspace:*",
+    "rocketh": "^0.17.14",
+    "typescript": "~5.9.3",
+    "viem": "^2.43.0"
+  },
+  "scripts": {
+    "test": "hardhat test"
+  }
+}