hardhat 3.0.0-next.2 → 3.0.0-next.20

package/src/internal/builtin-plugins/network-manager/config-resolution.ts

@@ -2,9 +2,9 @@ import type {
   ConfigurationVariableResolver,
   EdrNetworkAccountsConfig,
   EdrNetworkAccountsUserConfig,
-  EdrNetworkChainConfig,
-  EdrNetworkChainsConfig,
-  EdrNetworkChainsUserConfig,
+  ChainDescriptorConfig,
+  ChainDescriptorsConfig,
+  ChainDescriptorsUserConfig,
   EdrNetworkConfig,
   EdrNetworkForkingConfig,
   EdrNetworkForkingUserConfig,
@@ -17,24 +17,27 @@ import type {
   HttpNetworkAccountsUserConfig,
   HttpNetworkConfig,
   HttpNetworkUserConfig,
-  NetworkConfig,
-  NetworkUserConfig,
 } from "../../../types/config.js";
+import type { ChainType } from "../../../types/network.js";
 
 import path from "node:path";
 
+import { toBigInt } from "@nomicfoundation/hardhat-utils/bigint";
 import {
   hexStringToBytes,
   normalizeHexString,
 } from "@nomicfoundation/hardhat-utils/hex";
-import { isObject } from "@nomicfoundation/hardhat-utils/lang";
+import { deepClone } from "@nomicfoundation/hardhat-utils/lang";
+
+import { GENERIC_CHAIN_TYPE } from "../../constants.js";
 
 import { DEFAULT_HD_ACCOUNTS_CONFIG_PARAMS } from "./accounts/constants.js";
+import { DEFAULT_CHAIN_DESCRIPTORS } from "./chain-descriptors.js";
 import {
   DEFAULT_EDR_NETWORK_HD_ACCOUNTS_CONFIG_PARAMS,
   EDR_NETWORK_DEFAULT_COINBASE,
 } from "./edr/edr-provider.js";
-import { HardforkName, LATEST_HARDFORK } from "./edr/types/hardfork.js";
+import { getCurrentHardfork } from "./edr/types/hardfork.js";
 import { isHttpNetworkHdAccountsUserConfig } from "./type-validation.js";
 
 export function resolveHttpNetwork(
@@ -54,7 +57,7 @@ export function resolveHttpNetwork(
     gasMultiplier: networkConfig.gasMultiplier ?? 1,
     gasPrice: resolveGasConfig(networkConfig.gasPrice),
     url: resolveConfigurationVariable(networkConfig.url),
-    timeout: networkConfig.timeout ?? 20_000,
+    timeout: networkConfig.timeout ?? 300_000,
     httpHeaders: networkConfig.httpHeaders ?? {},
   };
 }
@@ -82,7 +85,6 @@ export function resolveEdrNetwork(
     allowUnlimitedContractSize:
       networkConfig.allowUnlimitedContractSize ?? false,
     blockGasLimit: BigInt(networkConfig.blockGasLimit ?? 30_000_000n),
-    chains: resolveChains(networkConfig.chains),
     coinbase: resolveCoinbase(networkConfig.coinbase),
     enableRip7212: networkConfig.enableRip7212 ?? false,
     enableTransientStorage: networkConfig.enableTransientStorage ?? false,
@@ -93,6 +95,7 @@ export function resolveEdrNetwork(
     ),
     hardfork: resolveHardfork(
       networkConfig.hardfork,
+      networkConfig.chainType,
       networkConfig.enableTransientStorage,
     ),
     initialBaseFeePerGas: resolveInitialBaseFeePerGas(
@@ -109,82 +112,6 @@ export function resolveEdrNetwork(
   };
 }
 
-/**
- * Resolves a NetworkUserConfig into a Partial<NetworkConfig> object.
- * This function processes the network configuration override using the appropriate
- * resolver (either HTTP or EDR) and ensures only the values explicitly specified
- * in the override are included in the final result, preventing defaults from
- * overwriting the user's configuration.
- *
- * @param networkUserConfigOverride The user's network configuration override.
- * @param resolveConfigurationVariable A function to resolve configuration variables.
- * @returns A Partial<NetworkConfig> containing the resolved values from the override.
- */
-export function resolveNetworkConfigOverride(
-  networkUserConfigOverride: NetworkUserConfig,
-  resolveConfigurationVariable: ConfigurationVariableResolver,
-): Partial<NetworkConfig> {
-  let resolvedConfigOverride: NetworkConfig;
-
-  if (networkUserConfigOverride.type === "http") {
-    resolvedConfigOverride = resolveHttpNetwork(
-      networkUserConfigOverride,
-      resolveConfigurationVariable,
-    );
-  } else {
-    resolvedConfigOverride = resolveEdrNetwork(
-      networkUserConfigOverride,
-      "",
-      resolveConfigurationVariable,
-    );
-  }
-
-  /* Return only the resolved config of the values overridden by the user. This
-  ensures that only the overridden values are merged into the config and
-  indirectly removes cacheDir from the resolved forking config, as cacheDir
-  is not part of the NetworkUserConfig. */
-  return pickResolvedFromOverrides(
-    resolvedConfigOverride,
-    networkUserConfigOverride,
-  );
-}
-
-function pickResolvedFromOverrides<
-  TResolved extends object,
-  TOverride extends object,
->(resolvedConfig: TResolved, overrides: TOverride): Partial<TResolved> {
-  const result: Partial<TResolved> = {};
-
-  for (const key of Object.keys(overrides)) {
-    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    -- As TResolved and TOverride are objects share the same keys, we can
-    safely cast the key */
-    const resolvedKey = key as keyof TResolved;
-    const resolvedValue = resolvedConfig[resolvedKey];
-    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    -- As TResolved and TOverride are objects share the same keys, we can
-    safely cast the key */
-    const overrideValue = overrides[key as keyof TOverride];
-
-    if (!(isObject(resolvedValue) && isObject(overrideValue))) {
-      result[resolvedKey] = resolvedValue;
-      continue;
-    }
-
-    /* Some properties in NetworkConfig, such as accounts, forking, and mining,
-    are objects themselves. To handle these, we process them recursively. */
-    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    -- The return type adheres to TResolved[keyof TResolved], but TS can't
-    infer it */
-    result[resolvedKey] = pickResolvedFromOverrides(
-      resolvedValue,
-      overrideValue,
-    ) as TResolved[keyof TResolved];
-  }
-
-  return result;
-}
-
 export function resolveGasConfig(value: GasUserConfig = "auto"): GasConfig {
   return value === "auto" ? value : BigInt(value);
 }
@@ -295,152 +222,67 @@ export function resolveCoinbase(
   return hexStringToBytes(coinbase);
 }
 
-export function resolveChains(
-  chains: EdrNetworkChainsUserConfig | undefined,
-): EdrNetworkChainsConfig {
-  const resolvedChains: EdrNetworkChainsConfig = new Map([
-    [
-      // block numbers below were taken from https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/common/src/chains
-      1, // mainnet
-      {
-        hardforkHistory: new Map([
-          [HardforkName.FRONTIER, 0],
-          [HardforkName.HOMESTEAD, 1_150_000],
-          [HardforkName.DAO, 1_920_000],
-          [HardforkName.TANGERINE_WHISTLE, 2_463_000],
-          [HardforkName.SPURIOUS_DRAGON, 2_675_000],
-          [HardforkName.BYZANTIUM, 4_370_000],
-          [HardforkName.CONSTANTINOPLE, 7_280_000],
-          [HardforkName.PETERSBURG, 7_280_000],
-          [HardforkName.ISTANBUL, 9_069_000],
-          [HardforkName.MUIR_GLACIER, 9_200_000],
-          [HardforkName.BERLIN, 1_2244_000],
-          [HardforkName.LONDON, 12_965_000],
-          [HardforkName.ARROW_GLACIER, 13_773_000],
-          [HardforkName.GRAY_GLACIER, 15_050_000],
-          [HardforkName.MERGE, 15_537_394],
-          [HardforkName.SHANGHAI, 17_034_870],
-          [HardforkName.CANCUN, 19_426_589],
-        ]),
-      },
-    ],
-    [
-      3, // ropsten
-      {
-        hardforkHistory: new Map([
-          [HardforkName.BYZANTIUM, 1700000],
-          [HardforkName.CONSTANTINOPLE, 4230000],
-          [HardforkName.PETERSBURG, 4939394],
-          [HardforkName.ISTANBUL, 6485846],
-          [HardforkName.MUIR_GLACIER, 7117117],
-          [HardforkName.BERLIN, 9812189],
-          [HardforkName.LONDON, 10499401],
-        ]),
-      },
-    ],
-    [
-      4, // rinkeby
-      {
-        hardforkHistory: new Map([
-          [HardforkName.BYZANTIUM, 1035301],
-          [HardforkName.CONSTANTINOPLE, 3660663],
-          [HardforkName.PETERSBURG, 4321234],
-          [HardforkName.ISTANBUL, 5435345],
-          [HardforkName.BERLIN, 8290928],
-          [HardforkName.LONDON, 8897988],
-        ]),
-      },
-    ],
-    [
-      5, // goerli
-      {
-        hardforkHistory: new Map([
-          [HardforkName.ISTANBUL, 1561651],
-          [HardforkName.BERLIN, 4460644],
-          [HardforkName.LONDON, 5062605],
-        ]),
-      },
-    ],
-    [
-      42, // kovan
-      {
-        hardforkHistory: new Map([
-          [HardforkName.BYZANTIUM, 5067000],
-          [HardforkName.CONSTANTINOPLE, 9200000],
-          [HardforkName.PETERSBURG, 10255201],
-          [HardforkName.ISTANBUL, 14111141],
-          [HardforkName.BERLIN, 24770900],
-          [HardforkName.LONDON, 26741100],
-        ]),
-      },
-    ],
-    [
-      11155111, // sepolia
-      {
-        hardforkHistory: new Map([
-          [HardforkName.GRAY_GLACIER, 0],
-          [HardforkName.MERGE, 1_450_409],
-          [HardforkName.SHANGHAI, 2_990_908],
-          [HardforkName.CANCUN, 5_187_023],
-        ]),
-      },
-    ],
-    // TODO: the rest of this config is a temporary workaround,
-    // see https://github.com/NomicFoundation/edr/issues/522
-    [
-      10, // optimism mainnet
-      {
-        hardforkHistory: new Map([[HardforkName.SHANGHAI, 0]]),
-      },
-    ],
-    [
-      11155420, // optimism sepolia
-      {
-        hardforkHistory: new Map([[HardforkName.SHANGHAI, 0]]),
-      },
-    ],
-    [
-      42161, // arbitrum one
-      {
-        hardforkHistory: new Map([[HardforkName.SHANGHAI, 0]]),
-      },
-    ],
-    [
-      421614, // arbitrum sepolia
-      {
-        hardforkHistory: new Map([[HardforkName.SHANGHAI, 0]]),
-      },
-    ],
-  ]);
-
-  if (chains === undefined) {
-    return resolvedChains;
+export async function resolveChainDescriptors(
+  chainDescriptors: ChainDescriptorsUserConfig | undefined,
+): Promise<ChainDescriptorsConfig> {
+  const resolvedChainDescriptors: ChainDescriptorsConfig = await deepClone(
+    DEFAULT_CHAIN_DESCRIPTORS,
+  );
+
+  if (chainDescriptors === undefined) {
+    return resolvedChainDescriptors;
   }
 
-  chains.forEach((chainConfig, chainId) => {
-    const resolvedChainConfig: EdrNetworkChainConfig = {
-      hardforkHistory: new Map(),
-    };
-    if (chainConfig.hardforkHistory !== undefined) {
-      chainConfig.hardforkHistory.forEach((block, name) => {
-        resolvedChainConfig.hardforkHistory.set(name, block);
-      });
+  // Loop over the user-provided chain descriptors
+  // and merge them with the default ones
+  for (const [chainId, userDescriptor] of Object.entries(chainDescriptors)) {
+    const existingDescriptor: ChainDescriptorConfig =
+      resolvedChainDescriptors.get(toBigInt(chainId)) ?? {
+        name: userDescriptor.name,
+        chainType: GENERIC_CHAIN_TYPE,
+        blockExplorers: {},
+      };
+
+    existingDescriptor.name = userDescriptor.name;
+
+    if (userDescriptor.chainType !== undefined) {
+      existingDescriptor.chainType = userDescriptor.chainType;
     }
-    resolvedChains.set(chainId, resolvedChainConfig);
-  });
 
-  return resolvedChains;
+    if (userDescriptor.hardforkHistory !== undefined) {
+      existingDescriptor.hardforkHistory = new Map(
+        Object.entries(userDescriptor.hardforkHistory),
+      );
+    }
+
+    if (userDescriptor.blockExplorers?.etherscan !== undefined) {
+      existingDescriptor.blockExplorers.etherscan = await deepClone(
+        userDescriptor.blockExplorers.etherscan,
+      );
+    }
+
+    if (userDescriptor.blockExplorers?.blockscout !== undefined) {
+      existingDescriptor.blockExplorers.blockscout = await deepClone(
+        userDescriptor.blockExplorers.blockscout,
+      );
+    }
+
+    resolvedChainDescriptors.set(toBigInt(chainId), existingDescriptor);
+  }
+
+  return resolvedChainDescriptors;
 }
 
 export function resolveHardfork(
   hardfork: string | undefined,
+  chainType: ChainType | undefined = GENERIC_CHAIN_TYPE,
   _enableTransientStorage: boolean | undefined,
 ): string {
   if (hardfork !== undefined) {
     return hardfork;
   }
 
-  return LATEST_HARDFORK;
+  return getCurrentHardfork(chainType);
 }
 
 export function resolveInitialBaseFeePerGas(

package/src/internal/builtin-plugins/network-manager/edr/edr-context.ts

@@ -4,8 +4,8 @@ import {
   genericChainProviderFactory,
   L1_CHAIN_TYPE,
   l1ProviderFactory,
-  OPTIMISM_CHAIN_TYPE,
-  optimismProviderFactory,
+  OP_CHAIN_TYPE,
+  opProviderFactory,
 } from "@ignored/edr-optimism";
 
 let _globalEdrContext: EdrContext | undefined;
@@ -22,8 +22,8 @@ export async function getGlobalEdrContext(): Promise<EdrContext> {
       l1ProviderFactory(),
     );
     await _globalEdrContext.registerProviderFactory(
-      OPTIMISM_CHAIN_TYPE,
-      optimismProviderFactory(),
+      OP_CHAIN_TYPE,
+      opProviderFactory(),
     );
   }
 

package/src/internal/builtin-plugins/network-manager/edr/edr-provider.ts

@@ -1,6 +1,8 @@
 import type { SolidityStackTrace } from "./stack-traces/solidity-stack-trace.js";
+import type { CoverageConfig } from "./types/coverage.js";
 import type { LoggerConfig } from "./types/logger.js";
 import type {
+  ChainDescriptorsConfig,
   EdrNetworkConfig,
   EdrNetworkHDAccountsConfig,
 } from "../../../../types/config.js";
@@ -11,6 +13,7 @@ import type {
   RequestArguments,
   SuccessfulJsonRpcResponse,
 } from "../../../../types/providers.js";
+import type { RequireField } from "../../../../types/utils.js";
 import type { DefaultHDAccountsConfigParams } from "../accounts/constants.js";
 import type { JsonRpcRequestWrapperFunction } from "../network-manager.js";
 import type {
@@ -19,13 +22,15 @@ import type {
   Provider,
   ProviderConfig,
   TracingConfigWithBuffers,
+  AccountOverride,
 } from "@ignored/edr-optimism";
 
 import {
-  optimismGenesisState,
-  optimismHardforkFromString,
+  opGenesisState,
+  opHardforkFromString,
   l1GenesisState,
   l1HardforkFromString,
+  precompileP256Verify,
 } from "@ignored/edr-optimism";
 import {
   assertHardhatInvariant,
@@ -36,6 +41,8 @@ import { ensureError } from "@nomicfoundation/hardhat-utils/error";
 import { numberToHexString } from "@nomicfoundation/hardhat-utils/hex";
 import { deepEqual } from "@nomicfoundation/hardhat-utils/lang";
 import debug from "debug";
+import { hexToBytes } from "ethereum-cryptography/utils";
+import { addr } from "micro-eth-signer";
 
 import { EDR_NETWORK_REVERT_SNAPSHOT_EVENT } from "../../../constants.js";
 import { DEFAULT_HD_ACCOUNTS_CONFIG_PARAMS } from "../accounts/constants.js";
@@ -61,7 +68,6 @@ import {
   hardhatMempoolOrderToEdrMineOrdering,
   hardhatHardforkToEdrSpecId,
   hardhatAccountsToEdrOwnedAccounts,
-  hardhatChainsToEdrChains,
   hardhatForkingConfigToEdrForkConfig,
   hardhatChainTypeToEdrChainType,
 } from "./utils/convert-to-edr.js";
@@ -125,10 +131,12 @@ export const EDR_NETWORK_DEFAULT_PRIVATE_KEYS: string[] = [
 ];
 
 interface EdrProviderConfig {
-  networkConfig: EdrNetworkConfig;
+  chainDescriptors: ChainDescriptorsConfig;
+  networkConfig: RequireField<EdrNetworkConfig, "chainType">;
   loggerConfig?: LoggerConfig;
   tracingConfig?: TracingConfigWithBuffers;
   jsonRpcRequestWrapper?: JsonRpcRequestWrapperFunction;
+  coverageConfig?: CoverageConfig;
 }
 
 export class EdrProvider extends BaseProvider {
@@ -141,15 +149,21 @@ export class EdrProvider extends BaseProvider {
    * Creates a new instance of `EdrProvider`.
    */
   public static async create({
+    chainDescriptors,
     networkConfig,
     loggerConfig = { enabled: false },
     tracingConfig = {},
     jsonRpcRequestWrapper,
+    coverageConfig,
   }: EdrProviderConfig): Promise<EdrProvider> {
     const printLineFn = loggerConfig.printLineFn ?? printLine;
     const replaceLastLineFn = loggerConfig.replaceLastLineFn ?? replaceLastLine;
 
-    const providerConfig = await getProviderConfig(networkConfig);
+    const providerConfig = await getProviderConfig(
+      networkConfig,
+      coverageConfig,
+      chainDescriptors,
+    );
 
     let edrProvider: EdrProvider;
 
@@ -162,7 +176,13 @@ export class EdrProvider extends BaseProvider {
         providerConfig,
         {
           enable: loggerConfig.enabled,
-          decodeConsoleLogInputsCallback: ConsoleLogger.getDecodedLogs,
+          decodeConsoleLogInputsCallback: (inputs: ArrayBuffer[]) => {
+            return ConsoleLogger.getDecodedLogs(
+              inputs.map((input) => {
+                return Buffer.from(input);
+              }),
+            );
+          },
           printLineCallback: (message: string, replace: boolean) => {
             if (replace) {
               replaceLastLineFn(message);
@@ -211,7 +231,7 @@ export class EdrProvider extends BaseProvider {
     requestArguments: RequestArguments,
   ): Promise<SuccessfulJsonRpcResponse["result"]> {
     if (this.#provider === undefined) {
-      throw new HardhatError(HardhatError.ERRORS.NETWORK.PROVIDER_CLOSED);
+      throw new HardhatError(HardhatError.ERRORS.CORE.NETWORK.PROVIDER_CLOSED);
     }
 
     const { method, params } = requestArguments;
@@ -382,23 +402,51 @@ export class EdrProvider extends BaseProvider {
 }
 
 async function getProviderConfig(
-  networkConfig: EdrNetworkConfig,
+  networkConfig: RequireField<EdrNetworkConfig, "chainType">,
+  coverageConfig: CoverageConfig | undefined,
+  chainDescriptors: ChainDescriptorsConfig,
 ): Promise<ProviderConfig> {
-  const genesisState =
+  const specId = hardhatHardforkToEdrSpecId(
+    networkConfig.hardfork,
+    networkConfig.chainType,
+  );
+
+  const ownedAccounts = await hardhatAccountsToEdrOwnedAccounts(
+    networkConfig.accounts,
+  );
+
+  const genesisState: Map<Uint8Array, AccountOverride> = new Map(
+    ownedAccounts.map(({ secretKey, balance }) => {
+      const address = hexToBytes(addr.fromPrivateKey(secretKey));
+      const accountOverride: AccountOverride = {
+        address,
+        balance: BigInt(balance),
+        code: new Uint8Array(), // Empty account code, removing potential delegation code when forking
+      };
+
+      return [address, accountOverride];
+    }),
+  );
+
+  const chainGenesisState =
     networkConfig.forking !== undefined
       ? [] // TODO: Add support for overriding remote fork state when the local fork is different
       : networkConfig.chainType === "optimism"
-        ? optimismGenesisState(
-            optimismHardforkFromString(
-              // TODO: Optimism conversion is not implemented yet
-              hardhatHardforkToEdrSpecId(networkConfig.hardfork),
-            ),
-          )
-        : l1GenesisState(
-            l1HardforkFromString(
-              hardhatHardforkToEdrSpecId(networkConfig.hardfork),
-            ),
-          );
+        ? opGenesisState(opHardforkFromString(specId))
+        : l1GenesisState(l1HardforkFromString(specId));
+
+  for (const account of chainGenesisState) {
+    const existingOverride = genesisState.get(account.address);
+    if (existingOverride !== undefined) {
+      // Favor the genesis state specified by the user
+      account.balance = account.balance ?? existingOverride.balance;
+      account.nonce = account.nonce ?? existingOverride.nonce;
+      account.code = account.code ?? existingOverride.code;
+      account.storage = account.storage ?? existingOverride.storage;
+    } else {
+      genesisState.set(account.address, account);
+    }
+  }
 
   return {
     allowBlocksWithSameTimestamp: networkConfig.allowBlocksWithSameTimestamp,
@@ -406,15 +454,15 @@ async function getProviderConfig(
     bailOnCallFailure: networkConfig.throwOnCallFailures,
     bailOnTransactionFailure: networkConfig.throwOnTransactionFailures,
     blockGasLimit: networkConfig.blockGasLimit,
-    cacheDir: networkConfig.forking?.cacheDir,
     chainId: BigInt(networkConfig.chainId),
-    chains: hardhatChainsToEdrChains(networkConfig.chains),
-    // TODO: remove this cast when EDR updates the interface to accept Uint8Array
-    coinbase: Buffer.from(networkConfig.coinbase),
-    enableRip7212: networkConfig.enableRip7212,
-    fork: await hardhatForkingConfigToEdrForkConfig(networkConfig.forking),
-    genesisState,
-    hardfork: hardhatHardforkToEdrSpecId(networkConfig.hardfork),
+    coinbase: networkConfig.coinbase,
+    fork: await hardhatForkingConfigToEdrForkConfig(
+      networkConfig.forking,
+      chainDescriptors,
+      networkConfig.chainType,
+    ),
+    genesisState: Array.from(genesisState.values()),
+    hardfork: specId,
     initialBaseFeePerGas: networkConfig.initialBaseFeePerGas,
     initialDate: BigInt(toSeconds(networkConfig.initialDate)),
     minGasPrice: networkConfig.minGasPrice,
@@ -430,8 +478,12 @@ async function getProviderConfig(
       },
     },
     networkId: BigInt(networkConfig.networkId),
-    ownedAccounts: await hardhatAccountsToEdrOwnedAccounts(
-      networkConfig.accounts,
-    ),
+    observability: {
+      codeCoverage: coverageConfig,
+    },
+    ownedAccounts: ownedAccounts.map((account) => account.secretKey),
+    precompileOverrides: networkConfig.enableRip7212
+      ? [precompileP256Verify()]
+      : [],
   };
 }

package/src/internal/builtin-plugins/network-manager/edr/stack-traces/stack-trace-solidity-errors.ts

@@ -328,7 +328,14 @@ export class SolidityCallSite implements NodeJS.CallSite {
     _functionName: string | undefined,
     _line: number | undefined,
   ) {
-    this.#sourceName = _sourceName;
+    // If the soruce name starts with `project/` that means that's a local
+    // source name, and we remove that.
+    const LOCAL_SOURCE_NAME_PREFIX = "project/";
+
+    this.#sourceName =
+      _sourceName?.startsWith(LOCAL_SOURCE_NAME_PREFIX) === true
+        ? _sourceName.substring(LOCAL_SOURCE_NAME_PREFIX.length)
+        : _sourceName;
     this.#contract = _contract;
     this.#functionName = _functionName;
     this.#line = _line;

package/src/internal/builtin-plugins/network-manager/edr/types/coverage.ts

@@ -0,0 +1,3 @@
+export interface CoverageConfig {
+  onCollectedCoverageCallback: (coverageData: Uint8Array[]) => void;
+}