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

package/dist/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/package.json

@@ -1,54 +1,84 @@
 {
   "name": "hardhat-deploy",
-  "version": "2.0.0-next.7",
-  "description": "deployment plugin for hardhat",
+  "version": "2.0.0-next.71",
+  "description": "Hardhat plugin for replicable smart contract deployments and easy testing across multiple EVM chains, with support for proxies, diamonds, named accounts, and deployment fixtures",
+  "keywords": [
+    "hardhat",
+    "ethereum",
+    "solidity",
+    "deployment",
+    "test",
+    "cli"
+  ],
+  "author": "Ronan Sandford",
+  "license": "MIT",
+  "homepage": "https://github.com/wighawag/hardhat-deploy#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wighawag/hardhat-deploy.git"
+  },
+  "bugs": {
+    "url": "https://github.com/wighawag/hardhat-deploy/issues"
+  },
   "publishConfig": {
     "access": "public"
   },
   "type": "module",
-  "main": "dist/esm/index.js",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/esm/index.d.ts",
+  "main": "dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/esm/index.d.ts",
-        "default": "./dist/esm/index.js"
-      }
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": "./dist/v1-entry.cjs"
     },
     "./helpers": {
       "import": {
-        "types": "./dist/esm/helpers.d.ts",
-        "default": "./dist/esm/helpers.js"
+        "types": "./dist/helpers.d.ts",
+        "default": "./dist/helpers.js"
       }
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "src",
+    "bin",
+    "templates"
   ],
+  "bin": {
+    "hardhat-deploy": "./dist/cli.js"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
   "devDependencies": {
-    "@changesets/cli": "^2.28.1",
-    "@types/node": "^22.13.10",
-    "as-soon": "^0.0.11",
-    "hardhat": "^3.0.0-next.1",
-    "rimraf": "^6.0.1",
-    "rocketh": "1.0.0-next.2",
+    "@changesets/cli": "^2.29.8",
+    "@rocketh/node": "0.17.21",
+    "@types/node": "^25.0.10",
+    "as-soon": "^0.1.5",
+    "hardhat": "3.1.5",
+    "rimraf": "^6.1.2",
+    "rocketh": "0.17.18",
     "set-defaults": "^0.0.5",
-    "typescript": "^5.5.2"
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "hardhat": "^3.0.0-next.1",
-    "rocketh": "1.0.0-next.2"
+    "@rocketh/node": "^0.17.21",
+    "hardhat": "^3.1.5"
   },
   "dependencies": {
-    "@nomicfoundation/hardhat-errors": "3.0.0-next.0",
-    "@nomicfoundation/hardhat-zod-utils": "3.0.0-next.0",
-    "@types/debug": "^4.1.12",
-    "debug": "^4.4.0",
-    "zod": "^3.24.2"
+    "@nomicfoundation/hardhat-zod-utils": "3.0.1",
+    "commander": "^14.0.2",
+    "named-logs": "^0.4.1",
+    "named-logs-console": "^0.5.1",
+    "zod": "^4.3.6"
   },
   "scripts": {
-    "build": "tsc --project tsconfig.json",
-    "dev": "as-soon -w src pnpm build"
+    "build": "tsc --project tsconfig.json && cp src/v1-entry.cjs dist/",
+    "dev": "as-soon -w src pnpm build",
+    "postinstall": "node ./dist/postinstall.js"
   }
 }

package/src/cli.ts

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { readFileSync, readdirSync, mkdirSync, copyFileSync, existsSync, writeFileSync, statSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+import * as readline from 'readline';
+import pkg from '../package.json' with { type: 'json' };
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const program = new Command();
+
+// Get the current version of hardhat-deploy
+const getHardhatDeployVersion = (): string => {
+  return pkg.version;
+};
+
+const askFolder = async (): Promise<string> => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question('Enter folder path (default: ./): ', (answer) => {
+      rl.close();
+      resolve(answer.trim() || './');
+    });
+  });
+};
+
+const askAutoInstall = async (): Promise<boolean> => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question('Auto-install dependencies with pnpm? (Y/n): ', (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      resolve(trimmed === '' || trimmed === 'y' || trimmed === 'yes');
+    });
+  });
+};
+
+const isFolderEmpty = (folderPath: string): boolean => {
+  if (!existsSync(folderPath)) {
+    return true;
+  }
+  
+  try {
+    const files = readdirSync(folderPath);
+    return files.length === 0;
+  } catch (error) {
+    // If we can't read the directory, treat it as not empty
+    return false;
+  }
+};
+
+const copyFile = (
+  source: string,
+  target: string,
+  replacements: Record<string, string> = {},
+  gitignorePatterns: string[] = []
+): void => {
+  const fileName = basename(source);
+  
+  // Check if file should be skipped based on gitignore patterns
+  for (const pattern of gitignorePatterns) {
+    if (fileName === pattern || fileName.endsWith(pattern.replace('*', ''))) {
+      return; // Skip this file
+    }
+  }
+  
+  let content = readFileSync(source, 'utf-8');
+  
+  // Apply replacements
+  for (const [search, replace] of Object.entries(replacements)) {
+    content = content.replaceAll(search, replace);
+  }
+  
+  mkdirSync(dirname(target), { recursive: true });
+  
+  // For binary files, just copy as-is
+  if (source.endsWith('.lock') || source.endsWith('.so') || source.endsWith('.wasm')) {
+    copyFileSync(source, target);
+  } else {
+    writeFileSync(target, content, 'utf-8');
+  }
+};
+
+const parseGitignore = (gitignorePath: string): string[] => {
+  if (!existsSync(gitignorePath)) {
+    return [];
+  }
+  
+  const content = readFileSync(gitignorePath, 'utf-8');
+  return content
+    .split('\n')
+    .map((line: string) => line.trim())
+    .filter((line: string) => line && !line.startsWith('#'));
+};
+
+const copyFolder = (
+  source: string,
+  target: string,
+  replacements: Record<string, string> = {},
+  gitignorePatterns: string[] = []
+): void => {
+  if (!existsSync(target)) {
+    mkdirSync(target, { recursive: true });
+  }
+
+  const files = readdirSync(source);
+
+  files.forEach((file) => {
+    const sourcePath = join(source, file);
+    const targetPath = join(target, file);
+
+    const stat = statSync(sourcePath);
+
+    if (stat.isDirectory()) {
+      // Check if directory should be skipped based on gitignore patterns
+      const shouldSkip = gitignorePatterns.some(pattern =>
+        file === pattern.replace('/', '') || pattern.startsWith('/') && file === pattern.slice(1)
+      );
+      
+      if (!shouldSkip) {
+        copyFolder(sourcePath, targetPath, replacements, gitignorePatterns);
+      }
+    } else {
+      copyFile(sourcePath, targetPath, replacements, gitignorePatterns);
+    }
+  });
+};
+
+const generateProject = (targetFolder: string, projectName?: string): void => {
+  // find template in published package
+  const templatePath = join(__dirname, '../templates/basic');
+  const gitignorePath = join(templatePath, '.gitignore');
+  
+  // Parse gitignore patterns
+  const gitignorePatterns = parseGitignore(gitignorePath);
+  
+  // Determine project name from folder or use placeholder
+  const folderName = projectName || basename(targetFolder === './' ? process.cwd() : targetFolder);
+  
+  // Get the current version of hardhat-deploy
+  const hardhatDeployVersion = getHardhatDeployVersion();
+  
+  const replacements: Record<string, string> = {
+    'template-hardhat-node-test-runner': `${folderName}`,
+    'workspace:*': hardhatDeployVersion,
+  };
+  
+  console.log(`Generating project in: ${targetFolder}`);
+  copyFolder(templatePath, targetFolder, replacements, gitignorePatterns);
+  console.log('✓ Project initialized successfully!');
+};
+
+const runPnpmInstall = async (folderPath: string): Promise<void> => {
+  console.log(`Installing dependencies...`);
+  const { spawn } = await import('child_process');
+  
+  return new Promise((resolve, reject) => {
+    // Use --ignore-workspace to ensure dependencies are installed locally
+    // This prevents pnpm from treating the target folder as part of a parent workspace
+    const pnpm = spawn('pnpm', ['install', '--ignore-workspace', `--no-frozen-lockfile`], {
+      cwd: folderPath,
+      stdio: 'inherit',
+    });
+
+    pnpm.on('close', (code) => {
+      if (code === 0) {
+        console.log('✓ Dependencies installed successfully!');
+        resolve();
+      } else {
+        reject(new Error(`pnpm install failed with exit code ${code}`));
+      }
+    });
+
+    pnpm.on('error', (error) => {
+      reject(error);
+    });
+  });
+};
+
+program
+  .name('hardhat-deploy')
+  .description('CLI for hardhat-deploy')
+  .version(pkg.version);
+
+program
+  .command('init')
+  .argument('[folder]', 'folder to initialize the project in')
+  .option('--install', 'auto-install dependencies with pnpm')
+  .description('Initialize a new hardhat-deploy project')
+  .action(async (folder?: string, options?: { install?: boolean }) => {
+    let targetFolder = folder;
+    let autoInstall = options?.install ?? false;
+    
+    // If no folder specified, ask user
+    if (!targetFolder) {
+      targetFolder = await askFolder();
+      // If we prompted for folder, also prompt for auto-install
+      autoInstall = await askAutoInstall();
+    }
+    
+    // Normalize path
+    targetFolder = targetFolder.trim();
+    
+    // Check if folder is empty
+    if (!isFolderEmpty(targetFolder)) {
+      console.error(`Error: Folder "${targetFolder}" is not empty. Please specify an empty folder or a new folder path.`);
+      process.exit(1);
+    }
+    
+    // Generate project
+    generateProject(targetFolder);
+    
+    // Auto-install if requested
+    if (autoInstall) {
+      try {
+        await runPnpmInstall(targetFolder);
+      } catch (error) {
+        console.error('Failed to install dependencies:', error);
+        console.log('\nYou can install dependencies manually:');
+        console.log(`  cd ${targetFolder === './' ? '.' : targetFolder}`);
+        console.log('  pnpm install');
+        process.exit(1);
+      }
+    }
+    
+    // Show next steps
+    console.log(`\nNext steps:`);
+    console.log(`  cd ${targetFolder === './' ? '.' : targetFolder}`);
+    if (!autoInstall) {
+      console.log(`  pnpm install`);
+    }
+    console.log(`  pnpm hardhat test`);
+  });
+
+program.parse();

package/src/config/default.ts

@@ -0,0 +1,6 @@
+import type {ArtifactGenerationConfig} from '../types.js';
+
+export const DEFAULT_CONFIG: ArtifactGenerationConfig = {
+	// externalArtifacts: [],
+	destinations: [{mode: 'javascript', folder: './generated'}],
+};

package/src/config/get-config.ts

@@ -0,0 +1,12 @@
+import type {ArtifactGenerationConfig, ArtifactGenerationUserConfig} from '../types.js';
+
+import {DEFAULT_CONFIG} from './default.js';
+
+export function getConfig(userConfig: ArtifactGenerationUserConfig | undefined): ArtifactGenerationConfig {
+	return {
+		destinations:
+			userConfig?.destinations?.map((v) => ({mode: v.mode || 'javascript', folder: v.folder || './generated'})) ||
+			DEFAULT_CONFIG.destinations,
+		// externalArtifacts: userConfig?.externalArtifacts || DEFAULT_CONFIG.externalArtifacts,
+	};
+}

package/src/config/validation.ts

@@ -0,0 +1,25 @@
+import type {HardhatUserConfigValidationError} from '@nomicfoundation/hardhat-zod-utils';
+import type {HardhatUserConfig} from 'hardhat/config';
+
+import {validateUserConfigZodType} from '@nomicfoundation/hardhat-zod-utils';
+import {z} from 'zod';
+
+const artifactGenerationUserConfigSchema = z
+	.object({
+		// externalArtifacts: z.array(z.string()).optional(),
+		destinations: z
+			.array(
+				z.object({
+					mode: z.union([z.literal('javascript'), z.literal('typescript')]).optional(),
+					folder: z.string().optional(),
+				})
+			)
+			.optional(),
+	})
+	.optional();
+
+export async function validateTypechainUserConfig(
+	userConfig: HardhatUserConfig
+): Promise<HardhatUserConfigValidationError[]> {
+	return validateUserConfigZodType(userConfig.generateTypedArtifacts, artifactGenerationUserConfigSchema);
+}