feat: override run task for zksync hardhat network (#1462)

* feat: add node task

* feat: refactor task node

* feat: update task node

* fix: call subtask for era test node start

* fix: set default port at 8545 for both node tasks

* feat: wrap deploy script run with era test node for the hardhat network

* fix: fix runScripts to be executed with node support and override default tasks with node support

* fix: add fund-up as root dependency and set 8011 as default port for node-zksync task

* fix: delete example unused files and packages

---------

Co-authored-by: nikola-bozin-txfusion <nikolabozin@txfusion.io>
Co-authored-by: Marko Arambasic <makiarambasic@gmail.com>

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