fixes for createServer

.changeset/cyan-dogs-ask.md

@@ -0,0 +1,5 @@
+---
+"hardhat": patch
+---
+
+Updated `network.createServer` signature to type non-generic chainTypes

.changeset/petite-teams-slide.md

@@ -0,0 +1,6 @@
+---
+"@nomicfoundation/hardhat-errors": patch
+"hardhat": patch
+---
+
+Added guard against `http` network configs in `network.createServer(...)`

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

@@ -1050,6 +1050,14 @@ account, and its parameters are incompatible. You sent both gasPrice and authori
 
 Please double check your transactions' parameters.`,
       },
+      CREATE_SERVER_UNSUPPORTED_NETWORK_TYPE: {
+        number: 724,
+        messageTemplate:
+          'Cannot create a server for network "{networkName}" because it has type "{networkType}". Only "edr-simulated" networks are supported.',
+        websiteTitle: "Unsupported network type for createServer",
+        websiteDescription:
+          "The createServer method only supports 'edr-simulated' networks. HTTP networks cannot be used to create a local JSON-RPC server.",
+      },
     },
     SOLIDITY_TESTS: {
       BUILD_INFO_NOT_FOUND_FOR_CONTRACT: {

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

@@ -110,11 +110,15 @@ export class NetworkManagerImplementation implements NetworkManager {
     return networkConnection as NetworkConnection<ChainTypeT>;
   }
 
-  public async createServer(
-    networkOrParams: NetworkConnectionParams | string = "default",
+  public async createServer<
+    ChainTypeT extends ChainType | string = DefaultChainType,
+  >(
+    networkOrParams?: NetworkConnectionParams<ChainTypeT> | string,
     _hostname?: string,
     port?: number,
   ): Promise<JsonRpcServer> {
+    this.#ensureNetworkOrParamsIsNotHttpNetworkConfig(networkOrParams);
+
     const insideDocker = await exists("/.dockerenv");
     const hostname = _hostname ?? (insideDocker ? "0.0.0.0" : "127.0.0.1");
 
@@ -434,4 +438,27 @@ export class NetworkManagerImplementation implements NetworkManager {
 
     return path;
   }
+
+  #ensureNetworkOrParamsIsNotHttpNetworkConfig(
+    networkOrParams?: NetworkConnectionParams<string> | string,
+  ) {
+    const networkName =
+      typeof networkOrParams === "string"
+        ? networkOrParams
+        : networkOrParams?.network ?? this.#defaultNetwork;
+
+    const networkConfig = this.#networkConfigs[networkName];
+
+    if (networkConfig === undefined || networkConfig.type === "edr-simulated") {
+      return;
+    }
+
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.NETWORK.CREATE_SERVER_UNSUPPORTED_NETWORK_TYPE,
+      {
+        networkName,
+        networkType: networkConfig.type,
+      },
+    );
+  }
 }

v-next/hardhat/src/types/network.ts

@@ -62,8 +62,8 @@ export interface NetworkManager {
    *
    * @return A `JsonRpcServer` instance that can be started with {@link JsonRpcServer.listen}.
    */
-  createServer(
-    networkOrParams?: NetworkConnectionParams | string,
+  createServer<ChainTypeT extends ChainType | string = DefaultChainType>(
+    networkOrParams?: NetworkConnectionParams<ChainTypeT> | string,
     hostname?: string,
     port?: number,
   ): Promise<JsonRpcServer>;

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

@@ -846,17 +846,55 @@ describe("NetworkManagerImplementation", () => {
   });
 
   describe("createServer", function () {
+    it("should throw an error if the network type is not edr-simulated", async () => {
+      await assertRejectsWithHardhatError(
+        networkManager.createServer("localhost"),
+        HardhatError.ERRORS.CORE.NETWORK.CREATE_SERVER_UNSUPPORTED_NETWORK_TYPE,
+        { networkName: "localhost", networkType: "http" },
+      );
+    });
+
+    it("should throw an error if network parameters specify an http network", async () => {
+      await assertRejectsWithHardhatError(
+        networkManager.createServer({ network: "localhost" }),
+        HardhatError.ERRORS.CORE.NETWORK.CREATE_SERVER_UNSUPPORTED_NETWORK_TYPE,
+        { networkName: "localhost", networkType: "http" },
+      );
+    });
+
     it("connects to a network and returns a JsonRpcServer that wraps around it", async () => {
       const server = await networkManager.createServer(
         "edrNetwork",
         "127.0.0.1",
       );
+
+      const { address, port } = await server.listen();
+
+      try {
+        const { provider } = await networkManager.connect({
+          network: "localhost",
+          override: { url: `http://${address}:${port}` },
+        });
+        await provider.request({ method: "eth_chainId" });
+      } finally {
+        await server.close();
+      }
+    });
+
+    it("connects to a network based on network parameters and returns a JsonRpcServer that wraps around it", async () => {
+      const server = await networkManager.createServer(
+        { network: "edrNetwork", chainType: "op" },
+        "127.0.0.1",
+      );
+
       const { address, port } = await server.listen();
+
       try {
         const { provider } = await networkManager.connect({
           network: "localhost",
           override: { url: `http://${address}:${port}` },
         });
+
         await provider.request({ method: "eth_chainId" });
       } finally {
         await server.close();