hardhat 2.12.5 → 2.12.7

package/src/internal/hardhat-network/jsonrpc/handler.ts

@@ -82,40 +82,23 @@ export class JsonRpcHandler {
     this._provider.addListener("notification", listener);
 
     ws.on("message", async (msg) => {
-      let rpcReq: JsonRpcRequest | undefined;
-      let rpcResp: JsonRpcResponse | undefined;
+      let rpcReq: JsonRpcRequest | JsonRpcRequest[];
+      let rpcResp: JsonRpcResponse | JsonRpcResponse[];
 
       try {
         rpcReq = _readWsRequest(msg as string);
 
-        if (!isValidJsonRequest(rpcReq)) {
-          throw new InvalidRequestError("Invalid request");
-        }
-
-        rpcResp = await this._handleRequest(rpcReq);
-
-        // If eth_subscribe was successful, keep track of the subscription id,
-        // so we can cleanup on websocket close.
-        if (
-          rpcReq.method === "eth_subscribe" &&
-          isSuccessfulJsonResponse(rpcResp)
-        ) {
-          subscriptions.push(rpcResp.result);
-        }
+        rpcResp = Array.isArray(rpcReq)
+          ? await Promise.all(
+              rpcReq.map((req) =>
+                this._handleSingleWsRequest(req, subscriptions)
+              )
+            )
+          : await this._handleSingleWsRequest(rpcReq, subscriptions);
       } catch (error) {
         rpcResp = _handleError(error);
       }
 
-      // Validate the RPC response.
-      if (!isValidJsonResponse(rpcResp)) {
-        // Malformed response coming from the provider, report to user as an internal error.
-        rpcResp = _handleError(new InternalError("Internal error"));
-      }
-
-      if (rpcReq !== undefined) {
-        rpcResp.id = rpcReq.id;
-      }
-
       ws.send(JSON.stringify(rpcResp));
     });
 
@@ -155,7 +138,9 @@ export class JsonRpcHandler {
     res.end(JSON.stringify(rpcResp));
   }
 
-  private async _handleSingleRequest(req: any): Promise<JsonRpcResponse> {
+  private async _handleSingleRequest(
+    req: JsonRpcRequest
+  ): Promise<JsonRpcResponse> {
     if (!isValidJsonRequest(req)) {
       return _handleError(new InvalidRequestError("Invalid request"));
     }
@@ -182,6 +167,24 @@ export class JsonRpcHandler {
     return rpcResp;
   }
 
+  private async _handleSingleWsRequest(
+    rpcReq: JsonRpcRequest,
+    subscriptions: string[]
+  ) {
+    const rpcResp = await this._handleSingleRequest(rpcReq);
+
+    // If eth_subscribe was successful, keep track of the subscription id,
+    // so we can cleanup on websocket close.
+    if (
+      rpcReq.method === "eth_subscribe" &&
+      isSuccessfulJsonResponse(rpcResp)
+    ) {
+      subscriptions.push(rpcResp.result);
+    }
+
+    return rpcResp;
+  }
+
   private _handleRequest = async (
     req: JsonRpcRequest
   ): Promise<JsonRpcResponse> => {
@@ -218,7 +221,7 @@ const _readJsonHttpRequest = async (req: IncomingMessage): Promise<any> => {
   return json;
 };
 
-const _readWsRequest = (msg: string): JsonRpcRequest => {
+const _readWsRequest = (msg: string): JsonRpcRequest | JsonRpcRequest[] => {
   let json: any;
   try {
     json = JSON.parse(msg);

package/src/internal/hardhat-network/provider/modules/evm.ts

@@ -32,6 +32,7 @@ export class EvmModule {
     private readonly _node: HardhatNode,
     private readonly _miningTimer: MiningTimer,
     private readonly _logger: ModulesLogger,
+    private readonly _allowBlocksWithSameTimestamp: boolean,
     private readonly _experimentalHardhatNetworkMessageTraceHooks: BoundExperimentalHardhatNetworkMessageTraceHook[] = []
   ) {}
 
@@ -86,12 +87,23 @@ export class EvmModule {
     const latestBlock = await this._node.getLatestBlock();
     const increment = BigInt(timestamp) - latestBlock.header.timestamp;
 
-    if (increment <= 0n) {
+    if (increment < 0n) {
       throw new InvalidInputError(
-        `Timestamp ${timestamp.toString()} is lower than or equal to previous block's timestamp` +
-          ` ${latestBlock.header.timestamp}`
+        `Timestamp ${timestamp.toString()} is lower than the previous block's timestamp ${
+          latestBlock.header.timestamp
+        }`
       );
     }
+
+    if (!this._allowBlocksWithSameTimestamp && increment === 0n) {
+      throw new InvalidInputError(
+        `Timestamp ${timestamp.toString()} is equal to the previous block's timestamp.
+
+Enable the "allowBlocksWithSameTimestamp" option in the Hardhat network configuration to allow this.
+`
+      );
+    }
+
     this._node.setNextBlockTimestamp(BigInt(timestamp));
     return timestamp.toString();
   }

package/src/internal/hardhat-network/provider/node-types.ts

@@ -24,7 +24,6 @@ interface CommonConfig {
   hardfork: string;
   minGasPrice: bigint;
   networkId: number;
-  networkName: string;
   allowUnlimitedContractSize?: boolean;
   initialDate?: Date;
   tracingConfig?: TracingConfig;
@@ -32,6 +31,7 @@ interface CommonConfig {
   mempoolOrder: MempoolOrder;
   coinbase: string;
   chains: HardhatNetworkChainsConfig;
+  allowBlocksWithSameTimestamp: boolean;
 }
 
 export type LocalNodeConfig = CommonConfig;

package/src/internal/hardhat-network/provider/node.ts

@@ -146,6 +146,7 @@ export class HardhatNode extends EventEmitter {
       mempoolOrder,
       networkId,
       chainId,
+      allowBlocksWithSameTimestamp,
     } = config;
 
     let stateManager: StateManager;
@@ -293,6 +294,7 @@ export class HardhatNode extends EventEmitter {
       hardfork,
       hardforkActivations,
       mixHashGenerator,
+      allowBlocksWithSameTimestamp,
       tracingConfig,
       forkNetworkId,
       forkBlockNum,
@@ -378,6 +380,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     public readonly hardfork: HardforkName,
     private readonly _hardforkActivations: HardforkHistoryConfig,
     private _mixHashGenerator: RandomBufferGenerator,
+    private _allowBlocksWithSameTimestamp: boolean,
     tracingConfig?: TracingConfig,
     private _forkNetworkId?: number,
     private _forkBlockNumber?: bigint,
@@ -494,7 +497,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     const [, offsetShouldChange, newOffset] = timestampAndOffset;
 
     const needsTimestampIncrease =
-      await this._timestampClashesWithPreviousBlockOne(blockTimestamp);
+      !this._allowBlocksWithSameTimestamp &&
+      (await this._timestampClashesWithPreviousBlockOne(blockTimestamp));
     if (needsTimestampIncrease) {
       blockTimestamp += 1n;
     }

package/src/internal/hardhat-network/provider/provider.ts

@@ -58,6 +58,30 @@ const PRIVATE_RPC_METHODS = new Set([
 
 export const DEFAULT_COINBASE = "0xc014ba5ec014ba5ec014ba5ec014ba5ec014ba5e";
 
+interface HardhatNetworkProviderConfig {
+  hardfork: string;
+  chainId: number;
+  networkId: number;
+  blockGasLimit: number;
+  minGasPrice: bigint;
+  automine: boolean;
+  intervalMining: IntervalMiningConfig;
+  mempoolOrder: MempoolOrder;
+  chains: HardhatNetworkChainsConfig;
+  genesisAccounts: GenesisAccount[];
+  allowUnlimitedContractSize: boolean;
+  throwOnTransactionFailures: boolean;
+  throwOnCallFailures: boolean;
+  allowBlocksWithSameTimestamp: boolean;
+
+  initialBaseFeePerGas?: number;
+  initialDate?: Date;
+  coinbase?: string;
+  experimentalHardhatNetworkMessageTraceHooks?: BoundExperimentalHardhatNetworkMessageTraceHook[];
+  forkConfig?: ForkConfig;
+  forkCachePath?: string;
+}
+
 export class HardhatNetworkProvider
   extends EventEmitter
   implements EIP1193Provider
@@ -75,28 +99,9 @@ export class HardhatNetworkProvider
   private _common?: Common;
 
   constructor(
-    private readonly _hardfork: string,
-    private readonly _networkName: string,
-    private readonly _chainId: number,
-    private readonly _networkId: number,
-    private readonly _blockGasLimit: number,
-    private readonly _initialBaseFeePerGas: number | undefined,
-    private readonly _minGasPrice: bigint,
-    private readonly _throwOnTransactionFailures: boolean,
-    private readonly _throwOnCallFailures: boolean,
-    private readonly _automine: boolean,
-    private readonly _intervalMining: IntervalMiningConfig,
-    private readonly _mempoolOrder: MempoolOrder,
-    private readonly _chains: HardhatNetworkChainsConfig,
+    private readonly _config: HardhatNetworkProviderConfig,
     private readonly _logger: ModulesLogger,
-    private readonly _genesisAccounts: GenesisAccount[] = [],
-    private readonly _artifacts?: Artifacts,
-    private readonly _allowUnlimitedContractSize = false,
-    private readonly _initialDate?: Date,
-    private readonly _experimentalHardhatNetworkMessageTraceHooks: BoundExperimentalHardhatNetworkMessageTraceHook[] = [],
-    private _forkConfig?: ForkConfig,
-    private readonly _forkCachePath?: string,
-    private readonly _coinbase = DEFAULT_COINBASE
+    private readonly _artifacts?: Artifacts
   ) {
     super();
   }
@@ -228,24 +233,26 @@ export class HardhatNetworkProvider
     }
 
     const config: NodeConfig = {
-      automine: this._automine,
-      blockGasLimit: this._blockGasLimit,
-      minGasPrice: this._minGasPrice,
-      genesisAccounts: this._genesisAccounts,
-      allowUnlimitedContractSize: this._allowUnlimitedContractSize,
+      automine: this._config.automine,
+      blockGasLimit: this._config.blockGasLimit,
+      minGasPrice: this._config.minGasPrice,
+      genesisAccounts: this._config.genesisAccounts,
+      allowUnlimitedContractSize: this._config.allowUnlimitedContractSize,
       tracingConfig: await this._makeTracingConfig(),
-      initialBaseFeePerGas: this._initialBaseFeePerGas,
-      mempoolOrder: this._mempoolOrder,
-      hardfork: this._hardfork,
-      networkName: this._networkName,
-      chainId: this._chainId,
-      networkId: this._networkId,
-      initialDate: this._initialDate,
-      forkConfig: this._forkConfig,
+      initialBaseFeePerGas: this._config.initialBaseFeePerGas,
+      mempoolOrder: this._config.mempoolOrder,
+      hardfork: this._config.hardfork,
+      chainId: this._config.chainId,
+      networkId: this._config.networkId,
+      initialDate: this._config.initialDate,
+      forkConfig: this._config.forkConfig,
       forkCachePath:
-        this._forkConfig !== undefined ? this._forkCachePath : undefined,
-      coinbase: this._coinbase,
-      chains: this._chains,
+        this._config.forkConfig !== undefined
+          ? this._config.forkCachePath
+          : undefined,
+      coinbase: this._config.coinbase ?? DEFAULT_COINBASE,
+      chains: this._config.chains,
+      allowBlocksWithSameTimestamp: this._config.allowBlocksWithSameTimestamp,
     };
 
     const [common, node] = await HardhatNode.create(config);
@@ -256,10 +263,10 @@ export class HardhatNetworkProvider
     this._ethModule = new EthModule(
       common,
       node,
-      this._throwOnTransactionFailures,
-      this._throwOnCallFailures,
+      this._config.throwOnTransactionFailures,
+      this._config.throwOnCallFailures,
       this._logger,
-      this._experimentalHardhatNetworkMessageTraceHooks
+      this._config.experimentalHardhatNetworkMessageTraceHooks
     );
 
     const miningTimer = this._makeMiningTimer();
@@ -270,7 +277,8 @@ export class HardhatNetworkProvider
       node,
       miningTimer,
       this._logger,
-      this._experimentalHardhatNetworkMessageTraceHooks
+      this._config.allowBlocksWithSameTimestamp,
+      this._config.experimentalHardhatNetworkMessageTraceHooks
     );
     this._hardhatModule = new HardhatModule(
       node,
@@ -279,7 +287,7 @@ export class HardhatNetworkProvider
         this._logger.setEnabled(loggingEnabled);
       },
       this._logger,
-      this._experimentalHardhatNetworkMessageTraceHooks
+      this._config.experimentalHardhatNetworkMessageTraceHooks
     );
     this._debugModule = new DebugModule(node);
     this._personalModule = new PersonalModule(node);
@@ -320,13 +328,16 @@ export class HardhatNetworkProvider
   }
 
   private _makeMiningTimer(): MiningTimer {
-    const miningTimer = new MiningTimer(this._intervalMining, async () => {
-      try {
-        await this.request({ method: "hardhat_intervalMine" });
-      } catch (e) {
-        console.error("Unexpected error calling hardhat_intervalMine:", e);
+    const miningTimer = new MiningTimer(
+      this._config.intervalMining,
+      async () => {
+        try {
+          await this.request({ method: "hardhat_intervalMine" });
+        } catch (e) {
+          console.error("Unexpected error calling hardhat_intervalMine:", e);
+        }
       }
-    });
+    );
 
     miningTimer.start();
 
@@ -334,7 +345,7 @@ export class HardhatNetworkProvider
   }
 
   private async _reset(miningTimer: MiningTimer, forkConfig?: ForkConfig) {
-    this._forkConfig = forkConfig;
+    this._config.forkConfig = forkConfig;
     if (this._node !== undefined) {
       this._stopForwardingNodeEvents(this._node);
     }

package/src/internal/hardhat-network/provider/transactions/FakeSenderAccessListEIP2930Transaction.ts

@@ -16,6 +16,7 @@ import {
   InternalError,
   InvalidArgumentsError,
 } from "../../../core/providers/errors";
+import { makeFakeSignature } from "../utils/makeFakeSignature";
 
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
@@ -124,12 +125,14 @@ export class FakeSenderAccessListEIP2930Transaction extends AccessListEIP2930Tra
     data: AccessListEIP2930TxData = {},
     opts?: TxOptions
   ) {
+    const fakeSignature = makeFakeSignature(data, sender);
+
     super(
       {
         ...data,
         v: data.v ?? 1,
-        r: data.r ?? 1,
-        s: data.s ?? 2,
+        r: data.r ?? fakeSignature.r,
+        s: data.s ?? fakeSignature.s,
       },
       { ...opts, freeze: false }
     );

package/src/internal/hardhat-network/provider/transactions/FakeSenderEIP1559Transaction.ts

@@ -15,6 +15,7 @@ import {
   InternalError,
   InvalidArgumentsError,
 } from "../../../core/providers/errors";
+import { makeFakeSignature } from "../utils/makeFakeSignature";
 
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
@@ -123,12 +124,14 @@ export class FakeSenderEIP1559Transaction extends FeeMarketEIP1559Transaction {
     data: FeeMarketEIP1559TxData = {},
     opts?: TxOptions
   ) {
+    const fakeSignature = makeFakeSignature(data, sender);
+
     super(
       {
         ...data,
         v: data.v ?? 1,
-        r: data.r ?? 1,
-        s: data.s ?? 2,
+        r: data.r ?? fakeSignature.r,
+        s: data.s ?? fakeSignature.s,
       },
       { ...opts, freeze: false }
     );

package/src/internal/hardhat-network/provider/transactions/FakeSenderTransaction.ts

@@ -7,6 +7,7 @@ import {
   InternalError,
   InvalidArgumentsError,
 } from "../../../core/providers/errors";
+import { makeFakeSignature } from "../utils/makeFakeSignature";
 
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
@@ -97,12 +98,14 @@ export class FakeSenderTransaction extends Transaction {
   private readonly _sender: Address;
 
   constructor(sender: Address, data: TxData = {}, opts?: TxOptions) {
+    const fakeSignature = makeFakeSignature(data, sender);
+
     super(
       {
         ...data,
         v: data.v ?? 27,
-        r: data.r ?? 1,
-        s: data.s ?? 2,
+        r: data.r ?? fakeSignature.r,
+        s: data.s ?? fakeSignature.s,
       },
       { ...opts, freeze: false }
     );

package/src/internal/hardhat-network/provider/utils/makeFakeSignature.ts

@@ -0,0 +1,46 @@
+import {
+  AccessListEIP2930Transaction,
+  FeeMarketEIP1559Transaction,
+  TxData,
+} from "@nomicfoundation/ethereumjs-tx";
+import { Address } from "@nomicfoundation/ethereumjs-util";
+
+import { createNonCryptographicHashBasedIdentifier } from "../../../util/hash";
+
+// Produces a signature with r and s values taken from a hash of the inputs.
+export function makeFakeSignature(
+  tx: TxData | AccessListEIP2930Transaction | FeeMarketEIP1559Transaction,
+  sender: Address
+): {
+  r: number;
+  s: number;
+} {
+  const hashInputString = [
+    sender,
+    tx.nonce,
+    tx.gasLimit,
+    tx.value,
+    tx.to,
+    tx.data,
+    "gasPrice" in tx ? tx.gasPrice : "",
+    "chainId" in tx ? tx.chainId : "",
+    "maxPriorityFeePerGas" in tx ? tx.maxPriorityFeePerGas : "",
+    "maxFeePerGas" in tx ? tx.maxFeePerGas : "",
+    "accessList" in tx
+      ? tx.accessList?.map(([buf, bufs]) =>
+          [buf, ...bufs].map((b) => b.toString("hex")).join(";")
+        )
+      : "",
+  ]
+    .map((a) => a?.toString() ?? "")
+    .join(",");
+
+  const hashDigest = createNonCryptographicHashBasedIdentifier(
+    Buffer.from(hashInputString)
+  );
+
+  return {
+    r: hashDigest.readUInt32LE(),
+    s: hashDigest.readUInt32LE(4),
+  };
+}

package/src/internal/hardhat-network/provider/utils/putGenesisBlock.ts

@@ -12,7 +12,7 @@ import { getCurrentTimestamp } from "./getCurrentTimestamp";
 export async function putGenesisBlock(
   blockchain: HardhatBlockchain,
   common: Common,
-  { initialDate, blockGasLimit }: LocalNodeConfig,
+  { initialDate, blockGasLimit: initialBlockGasLimit }: LocalNodeConfig,
   stateTrie: Trie,
   hardfork: HardforkName,
   initialMixHash: Buffer,
@@ -27,7 +27,7 @@ export async function putGenesisBlock(
 
   const header: HeaderData = {
     timestamp: `0x${initialBlockTimestamp.toString(16)}`,
-    gasLimit: blockGasLimit,
+    gasLimit: initialBlockGasLimit,
     difficulty: isPostMerge ? 0 : 1,
     nonce: isPostMerge ? "0x0000000000000000" : "0x0000000000000042",
     extraData: "0x1234",

package/src/internal/solidity/resolver.ts

@@ -69,7 +69,10 @@ export class Resolver {
   constructor(
     private readonly _projectRoot: string,
     private readonly _parser: Parser,
-    private readonly _readFile: (absolutePath: string) => Promise<string>
+    private readonly _readFile: (absolutePath: string) => Promise<string>,
+    private readonly _transformImportName: (
+      importName: string
+    ) => Promise<string>
   ) {}
 
   /**
@@ -100,12 +103,14 @@ export class Resolver {
   /**
    * Resolves an import from an already resolved file.
    * @param from The file were the import statement is present.
-   * @param imported The path in the import statement.
+   * @param importName The path in the import statement.
    */
   public async resolveImport(
     from: ResolvedFile,
-    imported: string
+    importName: string
   ): Promise<ResolvedFile> {
+    const imported = await this._transformImportName(importName);
+
     const scheme = this._getUriScheme(imported);
     if (scheme !== undefined) {
       throw new HardhatError(ERRORS.RESOLVER.INVALID_IMPORT_PROTOCOL, {
@@ -182,14 +187,26 @@ export class Resolver {
           ERRORS.RESOLVER.LIBRARY_FILE_NOT_FOUND
         )
       ) {
-        throw new HardhatError(
-          ERRORS.RESOLVER.IMPORTED_FILE_NOT_FOUND,
-          {
-            imported,
-            from: from.sourceName,
-          },
-          error
-        );
+        if (imported !== importName) {
+          throw new HardhatError(
+            ERRORS.RESOLVER.IMPORTED_MAPPED_FILE_NOT_FOUND,
+            {
+              imported,
+              importName,
+              from: from.sourceName,
+            },
+            error
+          );
+        } else {
+          throw new HardhatError(
+            ERRORS.RESOLVER.IMPORTED_FILE_NOT_FOUND,
+            {
+              imported,
+              from: from.sourceName,
+            },
+            error
+          );
+        }
       }
 
       if (

package/src/internal/util/download.ts

@@ -1,9 +1,12 @@
+import type { Dispatcher } from "undici";
+
 import fs from "fs";
 import fsExtra from "fs-extra";
 import path from "path";
 import util from "util";
 
 import { getHardhatVersion } from "./packageInfo";
+import { shouldUseProxy } from "./proxy";
 
 const TEMP_FILE_PREFIX = "tmp-";
 
@@ -27,29 +30,24 @@ export async function download(
   const { getGlobalDispatcher, ProxyAgent, request } = await import("undici");
   const streamPipeline = util.promisify(pipeline);
 
-  function chooseDispatcher() {
-    if (process.env.HTTPS_PROXY !== undefined) {
-      return new ProxyAgent(process.env.HTTPS_PROXY);
-    }
-
-    if (process.env.HTTP_PROXY !== undefined) {
-      return new ProxyAgent(process.env.HTTP_PROXY);
-    }
-
-    return getGlobalDispatcher();
+  let dispatcher: Dispatcher;
+  if (process.env.http_proxy !== undefined && shouldUseProxy(url)) {
+    dispatcher = new ProxyAgent(process.env.http_proxy);
+  } else {
+    dispatcher = getGlobalDispatcher();
   }
 
   const hardhatVersion = getHardhatVersion();
 
   // Fetch the url
   const response = await request(url, {
-    dispatcher: chooseDispatcher(),
+    dispatcher,
     headersTimeout: timeoutMillis,
     maxRedirections: 10,
     method: "GET",
     headers: {
       ...extraHeaders,
-      "User-Agent": `hardhat ${hardhatVersion ?? "(unknown version)"}`,
+      "User-Agent": `hardhat ${hardhatVersion}`,
     },
   });
 
@@ -59,6 +57,9 @@ export async function download(
 
     await streamPipeline(response.body, fs.createWriteStream(tmpFilePath));
     return fsExtra.move(tmpFilePath, filePath, { overwrite: true });
+  } else {
+    // undici's response bodies must always be consumed to prevent leaks
+    await response.body.text();
   }
 
   // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error

package/src/internal/util/packageInfo.ts

@@ -2,6 +2,8 @@ import findup from "find-up";
 import fsExtra from "fs-extra";
 import path from "path";
 
+import { assertHardhatInvariant } from "../core/errors";
+
 export function getPackageJsonPath(): string {
   return findClosestPackageJson(__filename)!;
 }
@@ -38,17 +40,14 @@ export async function getPackageJson(): Promise<PackageJson> {
   return fsExtra.readJSON(path.join(root, "package.json"));
 }
 
-export function getHardhatVersion(): string | null {
+export function getHardhatVersion(): string {
   const packageJsonPath = findClosestPackageJson(__filename);
 
-  if (packageJsonPath === null) {
-    return null;
-  }
+  assertHardhatInvariant(
+    packageJsonPath !== null,
+    "There should be a package.json in hardhat-core's root directory"
+  );
 
-  try {
-    const packageJson = fsExtra.readJsonSync(packageJsonPath);
-    return packageJson.version;
-  } catch {
-    return null;
-  }
+  const packageJson = fsExtra.readJsonSync(packageJsonPath);
+  return packageJson.version;
 }

package/src/internal/util/proxy.ts

@@ -0,0 +1,18 @@
+export function shouldUseProxy(url: string): boolean {
+  const { hostname } = new URL(url);
+  const noProxy = process.env.NO_PROXY;
+
+  if (hostname === "localhost" || hostname === "127.0.0.1" || noProxy === "*") {
+    return false;
+  }
+
+  if (noProxy !== undefined && noProxy !== "") {
+    const noProxyList = noProxy.split(",");
+
+    if (noProxyList.includes(hostname)) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/types/artifacts.ts

@@ -195,6 +195,7 @@ export interface CompilerInput {
         [libraryName: string]: string;
       };
     };
+    remappings?: string[];
   };
 }