feat: allow config vars in account mnemonic and passphrase fields

Author: schaable

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

@@ -1,15 +1,25 @@
+import type { SensitiveString } from "../../../../types/config.js";
+
 import { HardhatError } from "@ignored/hardhat-vnext-errors";
 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 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: "",
+  };
 
 export function derivePrivateKeys(
   mnemonic: string,

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

@@ -49,9 +49,15 @@ export function resolveHttpNetworkAccounts(
   }
 
   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),
     };
   }
 
@@ -77,13 +83,19 @@ export function resolveEdrNetworkAccounts(
     });
   }
 
+  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),
   };
 }
 

Diff for: v-next/hardhat/src/internal/builtin-plugins/network-manager/edr/edr-provider.ts

@@ -1,10 +1,7 @@
 import type { SolidityStackTrace } from "./stack-traces/solidity-stack-trace.js";
 import type { LoggerConfig } from "./types/logger.js";
 import type { TracingConfig } from "./types/node-types.js";
-import type {
-  EdrNetworkConfig,
-  EdrNetworkHDAccountsConfig,
-} from "../../../../types/config.js";
+import type { EdrNetworkConfig } from "../../../../types/config.js";
 import type {
   EthereumProvider,
   EthSubscription,
@@ -18,6 +15,7 @@ import type {
   CompilerInput,
   CompilerOutput,
 } from "../../../../types/solidity/compiler-io.js";
+import type { DefaultHDAccountsConfigParams } from "../accounts/derive-private-keys.js";
 import type { JsonRpcRequestWrapperFunction } from "../network-manager.js";
 import type {
   RawTrace,
@@ -81,10 +79,16 @@ const log = debug("hardhat:core:hardhat-network:provider");
 export const EDR_NETWORK_DEFAULT_COINBASE =
   "0xc014ba5ec014ba5ec014ba5ec014ba5ec014ba5e";
 
+interface EdrNetworkDefaultHDAccountsConfigParams
+  extends DefaultHDAccountsConfigParams {
+  mnemonic: string;
+  accountsBalance: bigint;
+}
+
 export const EDR_NETWORK_MNEMONIC =
   "test test test test test test test test test test test junk";
 export const DEFAULT_EDR_NETWORK_BALANCE = 10000000000000000000000n;
-export const DEFAULT_EDR_NETWORK_HD_ACCOUNTS_CONFIG_PARAMS: EdrNetworkHDAccountsConfig =
+export const DEFAULT_EDR_NETWORK_HD_ACCOUNTS_CONFIG_PARAMS: EdrNetworkDefaultHDAccountsConfigParams =
   {
     ...DEFAULT_HD_ACCOUNTS_CONFIG_PARAMS,
     mnemonic: EDR_NETWORK_MNEMONIC,

Diff for: v-next/hardhat/src/internal/builtin-plugins/network-manager/edr/utils/convert-to-edr.ts

@@ -224,7 +224,7 @@ export function edrRpcDebugTraceToHardhat(
 export async function hardhatAccountsToEdrGenesisAccounts(
   accounts: EdrNetworkAccountsConfig,
 ): Promise<GenesisAccount[]> {
-  const normalizedAccounts = normalizeEdrNetworkAccountsConfig(accounts);
+  const normalizedAccounts = await normalizeEdrNetworkAccountsConfig(accounts);
 
   const accountPromises = normalizedAccounts.map(async (account) => ({
     secretKey: await account.privateKey.getHexString(),
@@ -234,19 +234,19 @@ export async function hardhatAccountsToEdrGenesisAccounts(
   return Promise.all(accountPromises);
 }
 
-function normalizeEdrNetworkAccountsConfig(
+async function normalizeEdrNetworkAccountsConfig(
   accounts: EdrNetworkAccountsConfig,
-): EdrNetworkAccountConfig[] {
+): Promise<EdrNetworkAccountConfig[]> {
   if (Array.isArray(accounts)) {
     return accounts;
   }
 
   return derivePrivateKeys(
-    accounts.mnemonic,
+    await accounts.mnemonic.get(),
     accounts.path,
     accounts.initialIndex,
     accounts.count,
-    accounts.passphrase,
+    await accounts.passphrase.get(),
   ).map((pk) => ({
     privateKey: new FixedValueConfigurationVariable(bytesToHexString(pk)),
     balance: accounts.accountsBalance ?? DEFAULT_EDR_NETWORK_BALANCE,

Diff for: v-next/hardhat/src/internal/builtin-plugins/network-manager/request-handlers/hanlders-array.ts

@@ -6,7 +6,7 @@ import type {
 
 import { numberToHexString } from "@ignored/hardhat-vnext-utils/hex";
 
-import { isHdAccountsUserConfig } from "../type-validation.js";
+import { isHdAccountsConfig } from "../type-validation.js";
 
 import { AutomaticSenderHandler } from "./handlers/accounts/automatic-sender-handler.js";
 import { FixedSenderHandler } from "./handlers/accounts/fixed-sender-handler.js";
@@ -96,15 +96,15 @@ export async function createHandlersArray<
       requestHandlers.push(
         new LocalAccountsHandler(networkConnection.provider, resolvedAccounts),
       );
-    } else if (isHdAccountsUserConfig(accounts)) {
+    } else if (isHdAccountsConfig(accounts)) {
       requestHandlers.push(
         new HDWalletHandler(
           networkConnection.provider,
-          accounts.mnemonic,
+          await accounts.mnemonic.get(),
           accounts.path,
           accounts.initialIndex,
           accounts.count,
-          accounts.passphrase,
+          await accounts.passphrase.get(),
         ),
       );
     }

Diff for: v-next/hardhat/src/internal/builtin-plugins/network-manager/type-extensions/config.ts

@@ -33,10 +33,10 @@ declare module "../../../../types/config.js" {
     | HttpNetworkHDAccountsUserConfig;
 
   export interface HttpNetworkHDAccountsUserConfig {
-    mnemonic: string;
+    mnemonic: SensitiveString;
     count?: number;
     initialIndex?: number;
-    passphrase?: string;
+    passphrase?: SensitiveString;
     path?: string;
   }
 
@@ -82,11 +82,11 @@ declare module "../../../../types/config.js" {
   }
 
   export interface EdrNetworkHDAccountsUserConfig {
-    mnemonic?: string;
+    mnemonic?: SensitiveString;
     accountsBalance?: string | bigint;
     count?: number;
     initialIndex?: number;
-    passphrase?: string;
+    passphrase?: SensitiveString;
     path?: string;
   }
 
@@ -151,10 +151,10 @@ declare module "../../../../types/config.js" {
     | HttpNetworkHDAccountsConfig;
 
   export interface HttpNetworkHDAccountsConfig {
-    mnemonic: string;
+    mnemonic: ResolvedConfigurationVariable;
     count: number;
     initialIndex: number;
-    passphrase: string;
+    passphrase: ResolvedConfigurationVariable;
     path: string;
   }
 
@@ -200,11 +200,11 @@ declare module "../../../../types/config.js" {
   }
 
   export interface EdrNetworkHDAccountsConfig {
-    mnemonic: string;
+    mnemonic: ResolvedConfigurationVariable;
     accountsBalance: bigint;
     count: number;
     initialIndex: number;
-    passphrase: string;
+    passphrase: ResolvedConfigurationVariable;
     path: string;
   }
 

Diff for: v-next/hardhat/src/internal/builtin-plugins/network-manager/type-validation.ts

@@ -1,6 +1,8 @@
 import type {
   HardhatUserConfig,
+  HttpNetworkAccountsConfig,
   HttpNetworkAccountsUserConfig,
+  HttpNetworkHDAccountsConfig,
   HttpNetworkHDAccountsUserConfig,
   NetworkConfig,
 } from "../../../types/config.js";
@@ -15,6 +17,7 @@ import {
   conditionalUnionType,
   configurationVariableSchema,
   resolvedConfigurationVariableSchema,
+  sensitiveStringSchema,
   sensitiveUrlSchema,
   unionType,
   validateUserConfigZodType,
@@ -48,10 +51,10 @@ const accountsPrivateKeyUserConfigSchema = unionType(
 );
 
 const httpNetworkHDAccountsUserConfigSchema = z.object({
-  mnemonic: z.string(),
+  mnemonic: sensitiveStringSchema,
   count: z.optional(nonnegativeIntSchema),
   initialIndex: z.optional(nonnegativeIntSchema),
-  passphrase: z.optional(z.string()),
+  passphrase: z.optional(sensitiveStringSchema),
   path: z.optional(z.string()),
 });
 
@@ -109,11 +112,11 @@ const edrNetworkAccountUserConfigSchema = z.object({
 });
 
 const edrNetworkHDAccountsUserConfigSchema = z.object({
-  mnemonic: z.optional(z.string()),
+  mnemonic: z.optional(sensitiveStringSchema),
   accountsBalance: z.optional(accountBalanceUserConfigSchema),
   count: z.optional(nonnegativeIntSchema),
   initialIndex: z.optional(nonnegativeIntSchema),
-  passphrase: z.optional(z.string()),
+  passphrase: z.optional(sensitiveStringSchema),
   path: z.optional(z.string()),
 });
 
@@ -279,10 +282,10 @@ const gasConfigSchema = unionType(
 );
 
 const httpNetworkHDAccountsConfigSchema = z.object({
-  mnemonic: z.string(),
+  mnemonic: resolvedConfigurationVariableSchema,
   count: nonnegativeIntSchema,
   initialIndex: nonnegativeIntSchema,
-  passphrase: z.string(),
+  passphrase: resolvedConfigurationVariableSchema,
   path: z.string(),
 });
 
@@ -322,11 +325,11 @@ const edrNetworkAccountConfigSchema = z.object({
 });
 
 const edrNetworkHDAccountsConfigSchema = z.object({
-  mnemonic: z.string(),
+  mnemonic: resolvedConfigurationVariableSchema,
   accountsBalance: accountBalanceConfigSchema,
   count: nonnegativeIntSchema,
   initialIndex: nonnegativeIntSchema,
-  passphrase: z.string(),
+  passphrase: resolvedConfigurationVariableSchema,
   path: z.string(),
 });
 
@@ -442,3 +445,9 @@ export function isHdAccountsUserConfig(
 ): accounts is HttpNetworkHDAccountsUserConfig {
   return isObject(accounts);
 }
+
+export function isHdAccountsConfig(
+  accounts: HttpNetworkAccountsConfig,
+): accounts is HttpNetworkHDAccountsConfig {
+  return isObject(accounts);
+}

Diff for: v-next/hardhat/test/internal/builtin-plugins/network-manager/hook-handlers/config.ts

@@ -729,7 +729,7 @@ describe("network-manager/hook-handlers/config", () => {
             [
               {
                 path: ["networks", "localhost", "accounts", "mnemonic"],
-                message: "Required",
+                message: "Expected a string or a Configuration Variable",
               },
             ],
           );
@@ -742,7 +742,7 @@ describe("network-manager/hook-handlers/config", () => {
             [
               {
                 path: ["networks", "localhost", "accounts", "mnemonic"],
-                message: "Expected string, received number",
+                message: "Expected a string or a Configuration Variable",
               },
             ],
           );
@@ -798,7 +798,7 @@ describe("network-manager/hook-handlers/config", () => {
             [
               {
                 path: ["networks", "localhost", "accounts", "mnemonic"],
-                message: "Required",
+                message: "Expected a string or a Configuration Variable",
               },
             ],
           );
@@ -811,7 +811,7 @@ describe("network-manager/hook-handlers/config", () => {
             [
               {
                 path: ["networks", "localhost", "accounts", "mnemonic"],
-                message: "Required",
+                message: "Expected a string or a Configuration Variable",
               },
             ],
           );
@@ -1124,7 +1124,7 @@ describe("network-manager/hook-handlers/config", () => {
               [
                 {
                   path: ["networks", "localhost", "accounts", "mnemonic"],
-                  message: "Expected string, received number",
+                  message: "Expected a string or a Configuration Variable",
                 },
               ],
             );
@@ -1411,11 +1411,11 @@ describe("network-manager/hook-handlers/config", () => {
             gasMultiplier: 1.5,
             gasPrice: 100n,
             accounts: {
-              mnemonic: "asd asd asd",
+              mnemonic: new FixedValueConfigurationVariable("asd asd asd"),
               initialIndex: 0,
               count: 20,
               path: "m/44'/60'/0'/0",
-              passphrase: "passphrase",
+              passphrase: new FixedValueConfigurationVariable("passphrase"),
             },
             url: new FixedValueConfigurationVariable(
               "http://node.myNetwork.com",

Diff for: v-next/hardhat/test/internal/builtin-plugins/network-manager/request-handlers/e2e.ts

@@ -1,4 +1,4 @@
-import type { HttpNetworkHDAccountsConfig } from "../../../../../src/types/config.js";
+import type { HttpNetworkHDAccountsUserConfig } from "../../../../../src/types/config.js";
 
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
@@ -196,7 +196,7 @@ describe("request-handlers - e2e", () => {
       const MOCKED_GAS_LIMIT = 21000;
       const GAS_MULTIPLIER = 1.337;
       const LATEST_BASE_FEE_IN_MOCKED_PROVIDER = 80;
-      const HD_ACCOUNT: HttpNetworkHDAccountsConfig = {
+      const HD_ACCOUNT: HttpNetworkHDAccountsUserConfig = {
         mnemonic:
           "couch hunt wisdom giant regret supreme issue sing enroll ankle type husband",
         path: "m/44'/60'/0'/0/",