Move V2 wrapped providers to v3

v-next/hardhat-errors/src/descriptors.ts

@@ -572,6 +572,21 @@ If you want to use a different chain type, please update your networks config.`,
       websiteTitle: "Invalid config override",
       websiteDescription: `The configuration override you provided is invalid.`,
     },
+    INVALID_GLOBAL_CHAIN_ID: {
+      number: 708,
+      messageTemplate:
+        "Hardhat was set to use chain id {configChainId}, but connected to a chain with id {connectionChainId}.",
+      websiteTitle: "Invalid global chain id",
+      websiteDescription: `Hardhat was set to use a chain id but connected to a chain with a different id`,
+    },
+    NO_REMOTE_ACCOUNT_AVAILABLE: {
+      number: 709,
+      messageTemplate:
+        "No local account was set and there are accounts in the remote node.",
+      websiteTitle: "No remote account available",
+      websiteDescription:
+        "No local account was set and there are accounts in the remote node",
+    },
   },
   KEYSTORE: {
     INVALID_KEYSTORE_FILE_FORMAT: {

v-next/hardhat/src/internal/builtin-plugins/network-manager/hook-handlers/network.ts

@@ -0,0 +1,72 @@
+import type {
+  JsonRpcRequest,
+  JsonRpcResponse,
+} from "../../../../types/providers.js";
+import type {
+  HookContext,
+  NetworkHooks,
+} from "@ignored/hardhat-vnext/types/hooks";
+import type {
+  ChainType,
+  NetworkConnection,
+} from "@ignored/hardhat-vnext/types/network";
+
+import { JsonRpcRequestModifier } from "../json-rpc-request-modifiers/json-rpc-request-modifier.js";
+
+export default async (): Promise<Partial<NetworkHooks>> => {
+  // This map is necessary because Hardhat V3 supports multiple networks, requiring us to track them
+  // to apply the appropriate modifiers to each request.
+  // When a connection is closed, it is removed from the map. Refer to "closeConnection" at the end of the file.
+  const jsonRpcRequestModifiers: Map<number, JsonRpcRequestModifier> =
+    new Map();
+
+  const handlers: Partial<NetworkHooks> = {
+    async onRequest<ChainTypeT extends ChainType | string>(
+      context: HookContext,
+      networkConnection: NetworkConnection<ChainTypeT>,
+      jsonRpcRequest: JsonRpcRequest,
+      next: (
+        nextContext: HookContext,
+        nextNetworkConnection: NetworkConnection<ChainTypeT>,
+        nextJsonRpcRequest: JsonRpcRequest,
+      ) => Promise<JsonRpcResponse>,
+    ) {
+      let jsonRpcRequestModifier = jsonRpcRequestModifiers.get(
+        networkConnection.id,
+      );
+
+      if (jsonRpcRequestModifier === undefined) {
+        jsonRpcRequestModifier = new JsonRpcRequestModifier(networkConnection);
+
+        jsonRpcRequestModifiers.set(
+          networkConnection.id,
+          jsonRpcRequestModifier,
+        );
+      }
+
+      const newJsonRpcRequest =
+        await jsonRpcRequestModifier.createModifiedJsonRpcRequest(
+          jsonRpcRequest,
+        );
+
+      return next(context, networkConnection, newJsonRpcRequest);
+    },
+
+    async closeConnection<ChainTypeT extends ChainType | string>(
+      context: HookContext,
+      networkConnection: NetworkConnection<ChainTypeT>,
+      next: (
+        nextContext: HookContext,
+        nextNetworkConnection: NetworkConnection<ChainTypeT>,
+      ) => Promise<void>,
+    ): Promise<void> {
+      if (jsonRpcRequestModifiers.has(networkConnection.id) === true) {
+        jsonRpcRequestModifiers.delete(networkConnection.id);
+      }
+
+      return next(context, networkConnection);
+    },
+  };
+
+  return handlers;
+};

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

@@ -12,6 +12,7 @@ const hardhatPlugin: HardhatPlugin = {
   hookHandlers: {
     config: import.meta.resolve("./hook-handlers/config.js"),
     hre: import.meta.resolve("./hook-handlers/hre.js"),
+    network: import.meta.resolve("./hook-handlers/network.js"),
   },
   globalOptions: [
     globalOption({

v-next/hardhat/src/internal/builtin-plugins/network-manager/json-rpc-request-modifiers/chain-id/chain-id-validator.ts

@@ -0,0 +1,35 @@
+import type { EthereumProvider } from "../../../../../types/providers.js";
+
+import { HardhatError } from "@ignored/hardhat-vnext-errors";
+
+import { ChainId } from "./chain-id.js";
+
+export class ChainIdValidator extends ChainId {
+  readonly #expectedChainId: number;
+
+  #alreadyValidated = false;
+  readonly #chainId: number | undefined;
+
+  constructor(provider: EthereumProvider, expectedChainId: number) {
+    super(provider);
+    this.#expectedChainId = expectedChainId;
+  }
+
+  public async validate(): Promise<void> {
+    if (!this.#alreadyValidated) {
+      const actualChainId = await this.getChainId();
+
+      if (actualChainId !== this.#expectedChainId) {
+        throw new HardhatError(
+          HardhatError.ERRORS.NETWORK.INVALID_GLOBAL_CHAIN_ID,
+          {
+            configChainId: this.#expectedChainId,
+            connectionChainId: actualChainId,
+          },
+        );
+      }
+
+      this.#alreadyValidated = true;
+    }
+  }
+}

v-next/hardhat/src/internal/builtin-plugins/network-manager/json-rpc-request-modifiers/chain-id/chain-id.ts

@@ -0,0 +1,50 @@
+import type { EthereumProvider } from "../../../../../types/providers.js";
+
+import { assertHardhatInvariant } from "@ignored/hardhat-vnext-errors";
+
+import { rpcQuantityToNumber } from "../utils.js";
+
+export abstract class ChainId {
+  protected readonly provider: EthereumProvider;
+
+  #chainId: number | undefined;
+
+  constructor(provider: EthereumProvider) {
+    this.provider = provider;
+  }
+
+  protected async getChainId(): Promise<number> {
+    if (this.#chainId === undefined) {
+      try {
+        this.#chainId = await this.getChainIdFromEthChainId();
+      } catch {
+        // If eth_chainId fails we default to net_version
+        this.#chainId = await this.#getChainIdFromEthNetVersion();
+      }
+    }
+
+    return this.#chainId;
+  }
+
+  protected async getChainIdFromEthChainId(): Promise<number> {
+    const id = await this.provider.request({
+      method: "eth_chainId",
+    });
+
+    assertHardhatInvariant(typeof id === "string", "id should be a string");
+
+    return rpcQuantityToNumber(id);
+  }
+
+  async #getChainIdFromEthNetVersion(): Promise<number> {
+    const id = await this.provider.request({
+      method: "net_version",
+    });
+
+    assertHardhatInvariant(typeof id === "string", "id should be a string");
+
+    // There's a node returning this as decimal instead of QUANTITY.
+    // TODO: from V2 - Document here which node does that
+    return id.startsWith("0x") ? rpcQuantityToNumber(id) : parseInt(id, 10);
+  }
+}