feat: override run task for zksync hardhat network

package.json

@@ -12,6 +12,8 @@
     "husky": "^8.0.3",
     "prettier": "^3.3.0",
     "typescript": "^5.3.0",
+    "find-up": "^2.1.0",
+    "@types/find-up": "^2.1.1",
     "wsrun": "^5.2.2"
   },
   "scripts": {

packages/hardhat-zksync-deploy/src/core/config-env.ts

@@ -0,0 +1,27 @@
+import { ActionType, ConfigurableTaskDefinition, TaskArguments } from 'hardhat/types';
+import { HardhatContext } from 'hardhat/internal/context';
+import { ZKSyncTasksForWrapping, ZKSyncTasksWithWrappedNode } from './global-tasks';
+
+export function taskWithEraTestNode<TaskArgumentsT extends TaskArguments>(
+    name: string,
+    description?: string,
+    withNode?: boolean,
+    action?: ActionType<TaskArgumentsT>,
+): ConfigurableTaskDefinition {
+    const ctx = HardhatContext.getHardhatContext();
+    const dsl = ctx.tasksDSL;
+
+    if (withNode) {
+        if (!(global as ZKSyncTasksWithWrappedNode)._zkSyncTasksForWrapping) {
+            (global as ZKSyncTasksWithWrappedNode)._zkSyncTasksForWrapping = new ZKSyncTasksForWrapping();
+        }
+
+        (global as ZKSyncTasksWithWrappedNode)._zkSyncTasksForWrapping.addTask(name);
+    }
+
+    if (description === undefined) {
+        return dsl.task(name);
+    }
+
+    return dsl.task(name, description, action);
+}

packages/hardhat-zksync-deploy/src/core/global-tasks.ts

@@ -0,0 +1,18 @@
+import { Network } from 'hardhat/types';
+
+export type ZKSyncTasksWithWrappedNode = typeof global & {
+    _zkSyncTasksForWrapping: ZKSyncTasksForWrapping;
+    _zkSyncNodeNetwork?: Network;
+};
+
+export class ZKSyncTasksForWrapping {
+    public taskNames: string[] = [];
+
+    constructor() {
+        this.taskNames = [];
+    }
+
+    public addTask(taskName: string) {
+        this.taskNames.push(taskName);
+    }
+}

packages/hardhat-zksync-deploy/src/index.ts

@@ -1,12 +1,12 @@
-import { extendConfig, extendEnvironment, task, types } from 'hardhat/config';
+import { extendConfig, extendEnvironment, types } from 'hardhat/config';
 import chalk from 'chalk';
 import { string } from 'hardhat/internal/core/params/argumentTypes';
 import { TASK_DEPLOY_ZKSYNC, TASK_DEPLOY_ZKSYNC_LIBRARIES, TASK_DEPLOY_ZKSYNC_CONTRACT } from './task-names';
 import './type-extensions';
 import { deployZkSyncContract, zkSyncDeploy, zkSyncLibraryDeploy } from './task-actions';
 import { DEFAULT_DEPLOY_SCRIPTS_PATH, defaultAccountDeployerSettings } from './constants';
 import { DeployerExtension } from './deployer-extension';
-
+import { taskWithEraTestNode } from './core/config-env';
 export * from './deployer';
 
 extendConfig((config, userConfig) => {
@@ -27,12 +27,12 @@ extendEnvironment((hre) => {
     hre.deployer = new DeployerExtension(hre);
 });
 
-task(TASK_DEPLOY_ZKSYNC, 'Runs the deploy scripts for ZKsync network')
+taskWithEraTestNode(TASK_DEPLOY_ZKSYNC, 'Runs the deploy scripts for ZKsync network', true)
     .addParam('script', 'A certain deploy script to be launched', '')
     .addOptionalParam('tags', 'specify which deploy script to execute via tags, separated by commas', undefined, string)
     .setAction(zkSyncDeploy);
 
-task(TASK_DEPLOY_ZKSYNC_LIBRARIES, 'Runs the library deploy for ZKsync network')
+taskWithEraTestNode(TASK_DEPLOY_ZKSYNC_LIBRARIES, 'Runs the library deploy for ZKsync network', true)
     .addOptionalParam(
         'privateKeyOrIndex',
         'Private key or index of the account that will deploy the libraries',
@@ -53,7 +53,7 @@ task(TASK_DEPLOY_ZKSYNC_LIBRARIES, 'Runs the library deploy for ZKsync network')
     .addFlag('compileAllContracts', 'Flag to compile all contracts at the end of the process')
     .setAction(zkSyncLibraryDeploy);
 
-task(TASK_DEPLOY_ZKSYNC_CONTRACT, 'Runs the deploy scripts for ZKsync network')
+taskWithEraTestNode(TASK_DEPLOY_ZKSYNC_CONTRACT, 'Runs the deploy scripts for ZKsync network', true)
     .addParam('contractName', 'A contract name or a FQN', '')
     .addOptionalVariadicPositionalParam(
         'constructorArgsParams',

packages/hardhat-zksync-node/package.json

@@ -41,7 +41,9 @@
     "chai": "^4.3.4",
     "undici": "^6.18.2",
     "sinon-chai": "^3.7.0",
-    "sinon": "^18.0.0"
+    "sinon": "^18.0.0",
+    "source-map-support": "^0.5.21",
+    "debug": "^4.3.5"
   },
   "devDependencies": {
     "@types/chai": "^4.3.16",

packages/hardhat-zksync-node/src/core/global-interceptor.ts

@@ -0,0 +1,51 @@
+import { RunSuperFunction, TaskArguments } from 'hardhat/types';
+import { GlobalWithHardhatContext } from 'hardhat/src/internal/context';
+import { HARDHAT_NETWORK_NAME } from 'hardhat/plugins';
+import { configureNetwork, startServer, waitForNodeToBeReady } from '../utils';
+import { ZKSyncTasksWithWrappedNode } from './global-task';
+
+export function interceptAndWrapTasksWithNode() {
+    const zkSyncGlobal = global as ZKSyncTasksWithWrappedNode & GlobalWithHardhatContext;
+    const taskMap = zkSyncGlobal.__hardhatContext.tasksDSL.getTaskDefinitions();
+
+    if (!zkSyncGlobal._zkSyncTasksForWrapping) {
+        return;
+    }
+
+    zkSyncGlobal._zkSyncTasksForWrapping.taskNames.forEach((taskName) => {
+        const foundTask = taskMap[taskName];
+
+        if (!foundTask) {
+            return;
+        }
+
+        if (foundTask.isSubtask) {
+            zkSyncGlobal.__hardhatContext.tasksDSL.subtask(foundTask.name, foundTask.description, wrapTaskWithNode);
+        }
+
+        zkSyncGlobal.__hardhatContext.tasksDSL.task(foundTask.name, foundTask.description, wrapTaskWithNode);
+    });
+}
+
+async function wrapTaskWithNode(taskArgs: TaskArguments, env: any, runSuper: RunSuperFunction<TaskArguments>) {
+    if (env.network.zksync !== true || env.network.name !== HARDHAT_NETWORK_NAME) {
+        return await runSuper(taskArgs);
+    }
+    const zkSyncGlobal = global as ZKSyncTasksWithWrappedNode;
+    const { commandArgs, server, port } = await startServer();
+    try {
+        await server.listen(commandArgs, false);
+        await waitForNodeToBeReady(port);
+        const oldNetwork = env.network;
+        await configureNetwork(env.config, env.network, port);
+        env.injectToGlobal();
+        zkSyncGlobal._zkSyncNodeNetwork = env.network;
+        const result = await runSuper(taskArgs);
+        env.network = oldNetwork;
+        delete zkSyncGlobal._zkSyncNodeNetwork;
+        env.injectToGlobal();
+        return result;
+    } finally {
+        await server.stop();
+    }
+}

packages/hardhat-zksync-node/src/core/global-task.ts

@@ -0,0 +1,18 @@
+import { Network } from 'hardhat/types';
+
+export type ZKSyncTasksWithWrappedNode = typeof global & {
+    _zkSyncTasksForWrapping: ZKSyncTasksForWrapping;
+    _zkSyncNodeNetwork?: Network;
+};
+
+export class ZKSyncTasksForWrapping {
+    public taskNames: string[] = [];
+
+    constructor() {
+        this.taskNames = [];
+    }
+
+    public addTask(taskName: string) {
+        this.taskNames.push(taskName);
+    }
+}

packages/hardhat-zksync-node/src/core/register.ts

@@ -0,0 +1,77 @@
+import debug from 'debug';
+
+import { HardhatContext } from 'hardhat/internal/context';
+import { loadConfigAndTasks } from 'hardhat/internal/core/config/config-loading';
+import { getEnvHardhatArguments } from 'hardhat/internal/core/params/env-variables';
+import { HARDHAT_PARAM_DEFINITIONS } from 'hardhat/internal/core/params/hardhat-params';
+import { Environment } from 'hardhat/internal/core/runtime-environment';
+import { loadTsNode, willRunWithTypescript } from 'hardhat/internal/core/typescript-support';
+import { disableReplWriterShowProxy, isNodeCalledWithoutAScript } from 'hardhat/internal/util/console';
+import { LazyInitializationProviderAdapter } from 'hardhat/internal/core/providers/lazy-initialization';
+import { log } from 'console';
+import { createProvider } from 'hardhat/internal/core/providers/construction';
+import { MessageTrace } from 'hardhat/internal/hardhat-network/stack-traces/message-trace';
+import { Artifacts } from 'hardhat/internal/artifacts';
+import { BASE_URL, ZKSYNC_ERA_TEST_NODE_NETWORK_NAME } from '../constants';
+import { getNetworkConfig } from '../utils';
+
+if (!HardhatContext.isCreated()) {
+    require('source-map-support/register');
+
+    const ctx = HardhatContext.createHardhatContext();
+
+    if (isNodeCalledWithoutAScript()) {
+        disableReplWriterShowProxy();
+    }
+
+    const hardhatArguments = getEnvHardhatArguments(HARDHAT_PARAM_DEFINITIONS, process.env);
+
+    if (hardhatArguments.verbose) {
+        debug.enable('hardhat*');
+    }
+
+    if (willRunWithTypescript(hardhatArguments.config)) {
+        loadTsNode(hardhatArguments.tsconfig, hardhatArguments.typecheck);
+    }
+
+    const { resolvedConfig, userConfig } = loadConfigAndTasks(hardhatArguments);
+
+    const env = new Environment(
+        resolvedConfig,
+        hardhatArguments,
+        ctx.tasksDSL.getTaskDefinitions(),
+        ctx.tasksDSL.getScopesDefinitions(),
+        ctx.environmentExtenders,
+        ctx.experimentalHardhatNetworkMessageTraceHooks,
+        userConfig,
+        ctx.providerExtenders,
+    );
+
+    const zksyncNodePort = process.env.ZKNodePort;
+    const url = `${BASE_URL}:${zksyncNodePort}`;
+    const networkName = ZKSYNC_ERA_TEST_NODE_NETWORK_NAME;
+
+    env.network.name = networkName;
+    Object.assign(env.network.config, getNetworkConfig(url));
+    resolvedConfig.networks[env.network.name] = env.network.config;
+
+    const artifacts = new Artifacts(resolvedConfig.paths.artifacts);
+
+    const provider = new LazyInitializationProviderAdapter(async () => {
+        log(`Creating provider for network ${networkName}`);
+        return createProvider(
+            resolvedConfig,
+            networkName,
+            artifacts,
+            ctx.experimentalHardhatNetworkMessageTraceHooks.map(
+                (hook) => (trace: MessageTrace, isCallMessageTrace: boolean) => hook(env, trace, isCallMessageTrace),
+            ),
+            ctx.providerExtenders,
+        );
+    });
+
+    env.network.provider = provider;
+    ctx.setHardhatRuntimeEnvironment(env);
+
+    env.injectToGlobal();
+}

packages/hardhat-zksync-node/src/core/script-runner.ts

@@ -0,0 +1,87 @@
+import { isRunningHardhatCoreTests } from 'hardhat/internal/core/execution-mode';
+import { HardhatArguments } from 'hardhat/types';
+import { getEnvVariablesMap } from 'hardhat/internal/core/params/env-variables';
+import path from 'path';
+import { startServer, waitForNodeToBeReady } from '../utils';
+
+export async function runScript(
+    scriptPath: string,
+    scriptArgs: string[] = [],
+    extraNodeArgs: string[] = [],
+    extraEnvVars: { [name: string]: string } = {},
+): Promise<number> {
+    const { fork } = await import('child_process');
+    const processExecArgv = withFixedInspectArg(process.execArgv);
+
+    const nodeArgs = [
+        ...processExecArgv,
+        ...getTsNodeArgsIfNeeded(scriptPath, extraEnvVars.HARDHAT_TYPECHECK === 'true'),
+        ...extraNodeArgs,
+    ];
+
+    const { commandArgs, server, port } = await startServer();
+    await server.listen(commandArgs, false);
+    await waitForNodeToBeReady(port);
+
+    const envVars = { ...process.env, ...extraEnvVars, ZKNodePort: port.toString() };
+
+    return new Promise((resolve, reject) => {
+        const childProcess = fork(scriptPath, scriptArgs, {
+            stdio: 'inherit',
+            execArgv: nodeArgs,
+            env: envVars,
+        });
+
+        childProcess.once('close', async (status) => {
+            await server.stop();
+            resolve(status as number);
+        });
+
+        childProcess.once('error', async (error) => {
+            await server.stop();
+            reject(error);
+        });
+    });
+}
+
+export async function runScriptWithHardhat(
+    hardhatArguments: HardhatArguments,
+    scriptPath: string,
+    scriptArgs: string[] = [],
+    extraNodeArgs: string[] = [],
+    extraEnvVars: { [name: string]: string } = {},
+): Promise<number> {
+    return runScript(scriptPath, scriptArgs, [...extraNodeArgs, '--require', path.join(__dirname, 'register')], {
+        ...getEnvVariablesMap(hardhatArguments),
+        ...extraEnvVars,
+    });
+}
+
+function withFixedInspectArg(argv: string[]) {
+    const fixIfInspectArg = (arg: string) => {
+        if (arg.toLowerCase().includes('--inspect-brk=')) {
+            return '--inspect';
+        }
+        return arg;
+    };
+    return argv.map(fixIfInspectArg);
+}
+
+function getTsNodeArgsIfNeeded(scriptPath: string, shouldTypecheck: boolean): string[] {
+    if (process.execArgv.includes('ts-node/register')) {
+        return [];
+    }
+
+    // if we are running the tests we only want to transpile, or these tests
+    // take forever
+    if (isRunningHardhatCoreTests()) {
+        return ['--require', 'ts-node/register/transpile-only'];
+    }
+
+    // If the script we are going to run is .ts we need ts-node
+    if (/\.tsx?$/i.test(scriptPath)) {
+        return ['--require', `ts-node/register${shouldTypecheck ? '' : '/transpile-only'}`];
+    }
+
+    return [];
+}