Merge branch 'v-next' into test-solidity-no-compile

Author: galargh

v-next/hardhat/src/internal/builtin-plugins/network-manager/accounts/constants.ts

@@ -0,0 +1,16 @@
+import type { SensitiveString } from "../../../../types/config.js";
+
+export interface DefaultHDAccountsConfigParams {
+  initialIndex: number;
+  count: number;
+  path: string;
+  passphrase: SensitiveString;
+}
+
+export const DEFAULT_HD_ACCOUNTS_CONFIG_PARAMS: DefaultHDAccountsConfigParams =
+  {
+    initialIndex: 0,
+    count: 20,
+    path: "m/44'/60'/0'/0",
+    passphrase: "",
+  };

v-next/hardhat/src/internal/builtin-plugins/network-manager/accounts/derive-private-keys.ts

@@ -1,24 +1,18 @@
 import { HardhatError } from "@ignored/hardhat-vnext-errors";
+import { bytesToHexString } from "@ignored/hardhat-vnext-utils/bytes";
 import { mnemonicToSeedSync } from "ethereum-cryptography/bip39";
 import { HDKey } from "ethereum-cryptography/hdkey";
 
 const HD_PATH_REGEX = /^m(:?\/\d+'?)+\/?$/;
 
-export const DEFAULT_HD_ACCOUNTS_CONFIG_PARAMS = {
-  initialIndex: 0,
-  count: 20,
-  path: "m/44'/60'/0'/0",
-  passphrase: "",
-};
-
 export function derivePrivateKeys(
   mnemonic: string,
   hdpath: string,
   initialIndex: number,
   count: number,
   passphrase: string,
-): Buffer[] {
-  if (hdpath.match(HD_PATH_REGEX) === null) {
+): string[] {
+  if (!HD_PATH_REGEX.test(hdpath)) {
     throw new HardhatError(HardhatError.ERRORS.NETWORK.INVALID_HD_PATH, {
       path: hdpath,
     });
@@ -28,7 +22,7 @@ export function derivePrivateKeys(
     hdpath += "/";
   }
 
-  const privateKeys: Buffer[] = [];
+  const privateKeys: string[] = [];
 
   for (let i = initialIndex; i < initialIndex + count; i++) {
     const privateKey = deriveKeyFromMnemonicAndPath(
@@ -54,7 +48,7 @@ function deriveKeyFromMnemonicAndPath(
   mnemonic: string,
   hdPath: string,
   passphrase: string,
-): Buffer | undefined {
+): string | undefined {
   // NOTE: If mnemonic has space or newline at the beginning or end, it will be trimmed.
   // This is because mnemonic containing them may generate different private keys.
   const trimmedMnemonic = mnemonic.trim();
@@ -66,5 +60,5 @@ function deriveKeyFromMnemonicAndPath(
 
   return derived.privateKey === null
     ? undefined
-    : Buffer.from(derived.privateKey);
+    : bytesToHexString(derived.privateKey);
 }

v-next/hardhat/src/internal/builtin-plugins/network-manager/base-provider.ts

@@ -0,0 +1,76 @@
+import type {
+  EthereumProvider,
+  JsonRpcRequest,
+  JsonRpcResponse,
+  RequestArguments,
+  SuccessfulJsonRpcResponse,
+} from "../../../types/providers.js";
+
+import EventEmitter from "node:events";
+import util from "node:util";
+
+import { ensureError } from "@ignored/hardhat-vnext-utils/error";
+
+export abstract class BaseProvider
+  extends EventEmitter
+  implements EthereumProvider
+{
+  public abstract request(
+    requestArguments: RequestArguments,
+  ): Promise<SuccessfulJsonRpcResponse["result"]>;
+  public abstract close(): Promise<void>;
+
+  public send(
+    method: string,
+    params?: unknown[],
+  ): Promise<SuccessfulJsonRpcResponse["result"]> {
+    return this.request({ method, params });
+  }
+
+  public sendAsync(
+    jsonRpcRequest: JsonRpcRequest,
+    callback: (error: any, jsonRpcResponse: JsonRpcResponse) => void,
+  ): void {
+    const handleJsonRpcRequest = async () => {
+      let jsonRpcResponse: JsonRpcResponse;
+      try {
+        const result = await this.request({
+          method: jsonRpcRequest.method,
+          params: jsonRpcRequest.params,
+        });
+        jsonRpcResponse = {
+          jsonrpc: "2.0",
+          id: jsonRpcRequest.id,
+          result,
+        };
+      } catch (error) {
+        ensureError(error);
+
+        if (!("code" in error) || error.code === undefined) {
+          throw error;
+        }
+
+        /* eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        -- Allow string interpolation of unknown `error.code`. It will be converted
+        to a number, and we will handle NaN cases appropriately afterwards. */
+        const errorCode = parseInt(`${error.code}`, 10);
+        jsonRpcResponse = {
+          jsonrpc: "2.0",
+          id: jsonRpcRequest.id,
+          error: {
+            code: !isNaN(errorCode) ? errorCode : -1,
+            message: error.message,
+            data: {
+              stack: error.stack,
+              name: error.name,
+            },
+          },
+        };
+      }
+
+      return jsonRpcResponse;
+    };
+
+    util.callbackify(handleJsonRpcRequest)(callback);
+  }
+}

v-next/hardhat/src/internal/builtin-plugins/network-manager/config-resolution.ts

@@ -1,5 +1,5 @@
 import type {
-  ConfigurationResolver,
+  ConfigurationVariableResolver,
   EdrNetworkAccountsConfig,
   EdrNetworkAccountsUserConfig,
   EdrNetworkChainConfig,
@@ -22,21 +22,21 @@ import {
   normalizeHexString,
 } from "@ignored/hardhat-vnext-utils/hex";
 
-import { DEFAULT_HD_ACCOUNTS_CONFIG_PARAMS } from "./accounts/derive-private-keys.js";
+import { DEFAULT_HD_ACCOUNTS_CONFIG_PARAMS } from "./accounts/constants.js";
 import {
   DEFAULT_EDR_NETWORK_HD_ACCOUNTS_CONFIG_PARAMS,
   EDR_NETWORK_DEFAULT_COINBASE,
 } from "./edr/edr-provider.js";
-import { HardforkName } from "./edr/types/hardfork.js";
-import { isHdAccountsConfig } from "./type-validation.js";
+import { HardforkName, LATEST_HARDFORK } from "./edr/types/hardfork.js";
+import { isHdAccountsUserConfig } from "./type-validation.js";
 
 export function resolveGasConfig(value: GasUserConfig = "auto"): GasConfig {
   return value === "auto" ? value : BigInt(value);
 }
 
 export function resolveHttpNetworkAccounts(
   accounts: HttpNetworkAccountsUserConfig | undefined = "remote",
-  resolveConfigurationVariable: ConfigurationResolver,
+  resolveConfigurationVariable: ConfigurationVariableResolver,
 ): HttpNetworkAccountsConfig {
   if (Array.isArray(accounts)) {
     return accounts.map((acc) => {
@@ -48,10 +48,16 @@ export function resolveHttpNetworkAccounts(
     });
   }
 
-  if (isHdAccountsConfig(accounts)) {
+  if (isHdAccountsUserConfig(accounts)) {
+    const { passphrase: defaultPassphrase, ...defaultHdAccountRest } =
+      DEFAULT_HD_ACCOUNTS_CONFIG_PARAMS;
+    const { mnemonic, passphrase, ...hdAccountRest } = accounts;
+
     return {
-      ...DEFAULT_HD_ACCOUNTS_CONFIG_PARAMS,
-      ...accounts,
+      ...defaultHdAccountRest,
+      ...hdAccountRest,
+      mnemonic: resolveConfigurationVariable(mnemonic),
+      passphrase: resolveConfigurationVariable(passphrase ?? defaultPassphrase),
     };
   }
 
@@ -62,49 +68,55 @@ export function resolveEdrNetworkAccounts(
   accounts:
     | EdrNetworkAccountsUserConfig
     | undefined = DEFAULT_EDR_NETWORK_HD_ACCOUNTS_CONFIG_PARAMS,
+  resolveConfigurationVariable: ConfigurationVariableResolver,
 ): EdrNetworkAccountsConfig {
   if (Array.isArray(accounts)) {
-    return accounts.map(({ privateKey, balance }) => ({
-      privateKey: normalizeHexString(privateKey),
-      balance: BigInt(balance),
-    }));
+    return accounts.map(({ privateKey, balance }) => {
+      if (typeof privateKey === "string") {
+        privateKey = normalizeHexString(privateKey);
+      }
+
+      return {
+        privateKey: resolveConfigurationVariable(privateKey),
+        balance: BigInt(balance),
+      };
+    });
   }
 
+  const {
+    mnemonic: defaultMnemonic,
+    accountsBalance: defaultAccountsBalance,
+    passphrase: defaultPassphrase,
+    ...defaultHdAccountRest
+  } = DEFAULT_EDR_NETWORK_HD_ACCOUNTS_CONFIG_PARAMS;
+  const { mnemonic, passphrase, accountsBalance, ...hdAccountRest } = accounts;
   return {
-    ...DEFAULT_EDR_NETWORK_HD_ACCOUNTS_CONFIG_PARAMS,
-    ...accounts,
-    accountsBalance: BigInt(
-      accounts.accountsBalance ??
-        DEFAULT_EDR_NETWORK_HD_ACCOUNTS_CONFIG_PARAMS.accountsBalance,
-    ),
+    ...defaultHdAccountRest,
+    ...hdAccountRest,
+    mnemonic: resolveConfigurationVariable(mnemonic ?? defaultMnemonic),
+    accountsBalance: BigInt(accountsBalance ?? defaultAccountsBalance),
+    passphrase: resolveConfigurationVariable(passphrase ?? defaultPassphrase),
   };
 }
 
 export function resolveForkingConfig(
   forkingUserConfig: EdrNetworkForkingUserConfig | undefined,
   cacheDir: string,
+  resolveConfigurationVariable: ConfigurationVariableResolver,
 ): EdrNetworkForkingConfig | undefined {
   if (forkingUserConfig === undefined) {
     return undefined;
   }
 
-  const httpHeaders =
-    forkingUserConfig.httpHeaders !== undefined
-      ? Object.entries(forkingUserConfig.httpHeaders).map(([name, value]) => ({
-          name,
-          value,
-        }))
-      : undefined;
-
   return {
     enabled: forkingUserConfig.enabled ?? true,
-    url: forkingUserConfig.url,
+    url: resolveConfigurationVariable(forkingUserConfig.url),
     cacheDir: path.join(cacheDir, "edr-fork-cache"),
     blockNumber:
       forkingUserConfig.blockNumber !== undefined
         ? BigInt(forkingUserConfig.blockNumber)
         : undefined,
-    httpHeaders,
+    httpHeaders: forkingUserConfig.httpHeaders,
   };
 }
 
@@ -274,7 +286,7 @@ export function resolveHardfork(
   }
 
   if (enableTransientStorage === true) {
-    return HardforkName.CANCUN;
+    return LATEST_HARDFORK;
   } else {
     return HardforkName.SHANGHAI;
   }

v-next/hardhat/src/internal/builtin-plugins/network-manager/edr/edr-context.ts

@@ -0,0 +1,31 @@
+import {
+  EdrContext,
+  GENERIC_CHAIN_TYPE,
+  genericChainProviderFactory,
+  L1_CHAIN_TYPE,
+  l1ProviderFactory,
+  OPTIMISM_CHAIN_TYPE,
+  optimismProviderFactory,
+} from "@ignored/edr-optimism";
+
+let _globalEdrContext: EdrContext | undefined;
+
+export async function getGlobalEdrContext(): Promise<EdrContext> {
+  if (_globalEdrContext === undefined) {
+    _globalEdrContext = new EdrContext();
+    await _globalEdrContext.registerProviderFactory(
+      GENERIC_CHAIN_TYPE,
+      genericChainProviderFactory(),
+    );
+    await _globalEdrContext.registerProviderFactory(
+      L1_CHAIN_TYPE,
+      l1ProviderFactory(),
+    );
+    await _globalEdrContext.registerProviderFactory(
+      OPTIMISM_CHAIN_TYPE,
+      optimismProviderFactory(),
+    );
+  }
+
+  return _globalEdrContext;
+}