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

package/src/cli.ts

@@ -0,0 +1,244 @@
+#!/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) => {
+    const pnpm = spawn('pnpm', ['install'], {
+      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/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 the 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.
+- TypeScript integration tests using [`node:test`](nodejs.org/api/test.html) and the 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"
+  }
+}