hardhat 2.13.0-dev.1 → 2.13.0-dev.3

package/src/internal/solidity/dependencyGraph.ts

@@ -9,6 +9,7 @@ export class DependencyGraph implements taskTypes.DependencyGraph {
   ): Promise<DependencyGraph> {
     const graph = new DependencyGraph();
 
+    // TODO refactor this to make the results deterministic
     await Promise.all(
       resolvedFiles.map((resolvedFile) =>
         graph._addDependenciesFrom(resolver, resolvedFile)
@@ -169,6 +170,7 @@ export class DependencyGraph implements taskTypes.DependencyGraph {
     this._resolvedFiles.set(file.sourceName, file);
     this._dependenciesPerFile.set(file.sourceName, dependencies);
 
+    // TODO refactor this to make the results deterministic
     await Promise.all(
       file.content.imports.map(async (imp) => {
         const dependency = await resolver.resolveImport(file, imp);

package/src/internal/solidity/resolver.ts

@@ -8,6 +8,7 @@ import {
   ResolvedFile as IResolvedFile,
 } from "../../types/builtin-tasks";
 import {
+  includesOwnPackageName,
   isAbsolutePathSourceName,
   isLocalSourceName,
   normalizeSourceName,
@@ -68,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>
   ) {}
 
   /**
@@ -99,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, {
@@ -128,6 +134,15 @@ export class Resolver {
       });
     }
 
+    // Edge-case where an import can contain the current package's name in monorepos.
+    // The path can be resolved because there's a symlink in the node modules.
+    if (await includesOwnPackageName(imported)) {
+      throw new HardhatError(ERRORS.RESOLVER.INCLUDES_OWN_PACKAGE_NAME, {
+        from: from.sourceName,
+        imported,
+      });
+    }
+
     try {
       let sourceName: string;
 
@@ -172,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/abi-helpers.ts

@@ -26,6 +26,15 @@ export class AbiHelpers {
     }
   }
 
+  public static isValidCalldata(inputs: any[], calldata: Buffer): boolean {
+    try {
+      abi.defaultAbiCoder.decode(inputs, calldata);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   public static formatValues(values: any[]): string {
     return values.map((x) => AbiHelpers._formatValue(x)).join(", ");
   }

package/src/internal/util/console.ts

@@ -1,3 +1,5 @@
+import type ReplT from "repl";
+
 export function isNodeCalledWithoutAScript() {
   const script = process.argv[1];
   return script === undefined || script.trim() === "";
@@ -9,9 +11,9 @@ export function isNodeCalledWithoutAScript() {
  * so we disable it in hardhat/register.
  */
 export function disableReplWriterShowProxy() {
-  const repl = require("repl");
+  const repl = require("repl") as typeof ReplT;
 
-  if (repl.writer.options) {
+  if (repl.writer.options !== undefined) {
     Object.defineProperty(repl.writer.options, "showProxy", {
       value: false,
       writable: false,

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-";
 
@@ -20,34 +23,31 @@ function resolveTempFileName(filePath: string): string {
 export async function download(
   url: string,
   filePath: string,
-  timeoutMillis = 10000
+  timeoutMillis = 10000,
+  extraHeaders: { [name: string]: string } = {}
 ) {
   const { pipeline } = await import("stream");
   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: {
-      "User-Agent": `hardhat ${hardhatVersion ?? "(unknown version)"}`,
+      ...extraHeaders,
+      "User-Agent": `hardhat ${hardhatVersion}`,
     },
   });
 
@@ -58,11 +58,11 @@ export async function download(
     await streamPipeline(response.body, fs.createWriteStream(tmpFilePath));
     return fsExtra.move(tmpFilePath, filePath, { overwrite: true });
   }
+  // undici's response bodies must always be consumed to prevent leaks
+  const text = await response.body.text();
 
   // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
   throw new Error(
-    `Failed to download ${url} - ${
-      response.statusCode
-    } received. ${await response.body.text()}`
+    `Failed to download ${url} - ${response.statusCode} received. ${text}`
   );
 }

package/src/internal/util/keys-derivation.ts

@@ -11,7 +11,10 @@ export function deriveKeyFromMnemonicAndPath(
   }: {
     mnemonicToSeedSync: typeof mnemonicToSeedSyncT;
   } = require("ethereum-cryptography/bip39");
-  const seed = mnemonicToSeedSync(mnemonic, passphrase);
+  // NOTE: If mnemonic has space or newline at the beginning or end, it will be trimmed.
+  // This is because mnemonic containing them may generate different private keys.
+  const trimmedMnemonic = mnemonic.trim();
+  const seed = mnemonicToSeedSync(trimmedMnemonic, passphrase);
 
   const {
     HDKey,

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)!;
 }
@@ -15,6 +17,7 @@ export function getPackageRoot(): string {
 export interface PackageJson {
   name: string;
   version: string;
+  type?: "commonjs" | "module";
   engines: {
     node: string;
   };
@@ -24,22 +27,42 @@ export function findClosestPackageJson(file: string): string | null {
   return findup.sync("package.json", { cwd: path.dirname(file) });
 }
 
+export async function getPackageName(file: string): Promise<string> {
+  const packageJsonPath = findClosestPackageJson(file);
+  if (packageJsonPath !== null && packageJsonPath !== "") {
+    const packageJson: PackageJson = await fsExtra.readJSON(packageJsonPath);
+    return packageJson.name;
+  }
+  return "";
+}
+
 export async function getPackageJson(): Promise<PackageJson> {
   const root = getPackageRoot();
   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;
+}
+
+/**
+ * Return the contents of the package.json in the user's project
+ */
+export function getProjectPackageJson(): Promise<any> {
+  const packageJsonPath = findup.sync("package.json");
+
+  assertHardhatInvariant(
+    packageJsonPath !== null,
+    "Expected a package.json file in the current directory or in an ancestor directory"
+  );
+
+  return fsExtra.readJson(packageJsonPath);
 }

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/register.ts

@@ -38,16 +38,11 @@ if (!HardhatContext.isCreated()) {
 
   const { resolvedConfig, userConfig } = loadConfigAndTasks(hardhatArguments);
 
-  const artifactsExtensions = ctx.extendersManager
-    .getArtifactsExtenders()
-    .map((artifactsExtender) => artifactsExtender(resolvedConfig));
-
   const env = new Environment(
     resolvedConfig,
     hardhatArguments,
     ctx.tasksDSL.getTaskDefinitions(),
-    ctx.extendersManager.getEnvironmentExtenders(),
-    artifactsExtensions,
+    ctx.extendersManager.getExtenders(),
     ctx.experimentalHardhatNetworkMessageTraceHooks,
     userConfig
   );

package/src/types/artifacts.ts

@@ -41,6 +41,11 @@ export interface Artifacts {
    */
   getBuildInfo(fullyQualifiedName: string): Promise<BuildInfo | undefined>;
 
+  /**
+   * Synchronous version of getBuildInfo.
+   */
+  getBuildInfoSync(fullyQualifiedName: string): BuildInfo | undefined;
+
   /**
    * Returns an array with the absolute paths of all the existing artifacts.
    *
@@ -92,9 +97,7 @@ export interface Artifacts {
   ): Promise<string>;
 
   /**
-   * Returns the absolute path to the given artifact, as if it were saved
-   * locally, and not by a plugin (i.e. this method does not support
-   * ArtifactsExtension artifacts).
+   * Returns the absolute path to the given artifact.
    *
    * @param fullyQualifiedName The FQN of the artifact.
    */
@@ -108,7 +111,7 @@ export interface Artifacts {
    *
    * This method, if present, clears that cache.
    */
-  clearCache?(): void;
+  clearCache?: () => void;
 
   /**
    * This method, if present, disables the artifact paths cache.
@@ -119,106 +122,7 @@ export interface Artifacts {
    *
    * @see clearCache
    */
-  disableCache?(): void;
-}
-
-/**
- * Classes implementing this interface can be used as extra sources of
- * artifacts.
- *
- * Not every method needs to be fully implemented; some of them can have a
- * minimal valid implementation, as explained on their jsdocs.
- */
-export interface ArtifactsSource {
-  /**
-   * Reads an Artifact, returning `undefined` if not found.
-   * @see Artifacts#readArtifact
-   */
-  readArtifact(
-    contractNameOrFullyQualifiedName: string
-  ): Promise<Artifact | undefined>;
-
-  /**
-   * Reads an Artifact, returning `undefined` if not found.
-   * @see Artifacts#readArtifactSync
-   */
-  readArtifactSync(
-    contractNameOrFullyQualifiedName: string
-  ): Artifact | undefined;
-
-  /**
-   * @see Artifacts#artifactExists
-   */
-  artifactExists(contractNameOrFullyQualifiedName: string): Promise<boolean>;
-
-  /**
-   * Returns an array with the fully qualified names of all the artifacts.
-   *
-   * Always returning an empty array is a valid implementation.
-   *
-   * @see Artifacts#getAllFullyQualifiedNames
-   */
-  getAllFullyQualifiedNames(): Promise<string[]>;
-
-  /**
-   * Returns the BuildInfo associated with an artifact. Return `undefined` if
-   * there's none.
-   *
-   * Always returning `undefined` is a valid implementation if you don't handle
-   * BuildInfos.
-   *
-   * @see Artifacts#getBuildInfo
-   */
-  getBuildInfo(fullyQualifiedName: string): Promise<BuildInfo | undefined>;
-
-  /**
-   * Returns the paths of all the artifacts that the plugin can read.
-   *
-   * Always returning an empty array is a valid implementation.
-   *
-   * @see Artifacts#getArtifactPaths
-   */
-  getArtifactPaths(): Promise<string[]>;
-
-  /**
-   * Returns the paths of all the debug files associated with the artifacts that
-   * the plugin can read.
-   *
-   * Always returning an empty array is a valid implementation if you don't
-   * handle debug files.
-   *
-   * @see Artifacts#getDebugFilePaths
-   */
-  getDebugFilePaths(): Promise<string[]>;
-
-  /**
-   * Returns the paths of all the BuildInfos associated with the artifacts that
-   * the plugin can read.
-   *
-   * Always returning an empty array is a valid implementation if you don't
-   * handle BuildInfos.
-   *
-   * @see Artifacts#getBuildInfoPaths
-   */
-  getBuildInfoPaths(): Promise<string[]>;
-
-  /**
-   * Clears the internal cache, if any.
-   *
-   * An empty function is a valid implementation if you don't cache results.
-   *
-   * @see Artifacts#clearCache
-   */
-  clearCache: () => void;
-
-  /**
-   * Disables the internal cache, if any.
-   *
-   * An empty function is a valid implementation if you don't cache results.
-   *
-   * @see Artifacts#disableCache
-   */
-  disableCache: () => void;
+  disableCache?: () => void;
 }
 
 /**
@@ -278,7 +182,16 @@ export interface CompilerInput {
   language: string;
   sources: { [sourceName: string]: { content: string } };
   settings: {
-    optimizer: { runs?: number; enabled?: boolean };
+    viaIR?: boolean;
+    optimizer: {
+      runs?: number;
+      enabled?: boolean;
+      details?: {
+        yulDetails: {
+          optimizerSteps: string;
+        };
+      };
+    };
     metadata?: { useLiteralContent: boolean };
     outputSelection: {
       [sourceName: string]: {
@@ -291,6 +204,7 @@ export interface CompilerInput {
         [libraryName: string]: string;
       };
     };
+    remappings?: string[];
   };
 }
 

package/src/types/config.ts

@@ -51,6 +51,7 @@ export interface HardhatNetworkUserConfig {
   throwOnTransactionFailures?: boolean;
   throwOnCallFailures?: boolean;
   allowUnlimitedContractSize?: boolean;
+  allowBlocksWithSameTimestamp?: boolean;
   initialDate?: string;
   loggingEnabled?: boolean;
   forking?: HardhatNetworkForkingUserConfig;
@@ -151,6 +152,7 @@ export interface HardhatNetworkConfig {
   forking?: HardhatNetworkForkingConfig;
   coinbase?: string;
   chains: HardhatNetworkChainsConfig;
+  allowBlocksWithSameTimestamp?: boolean;
 }
 
 export type HardhatNetworkAccountsConfig =

package/src/types/runtime.ts

@@ -1,4 +1,4 @@
-import { Artifacts, ArtifactsSource } from "./artifacts";
+import { Artifacts } from "./artifacts";
 import { HardhatConfig, HardhatUserConfig, NetworkConfig } from "./config";
 import { EthereumProvider } from "./provider";
 
@@ -146,15 +146,22 @@ export interface TaskDefinition extends ConfigurableTaskDefinition {
  */
 export type TaskArguments = any;
 
-export interface RunSuperFunction<ArgT extends TaskArguments> {
-  (taskArguments?: ArgT): Promise<any>;
+export interface SubtaskArguments {
+  [subtaskName: string]: TaskArguments;
+}
+
+export interface RunSuperFunction<TaskArgumentsT extends TaskArguments> {
+  (
+    taskArguments?: TaskArgumentsT,
+    subtaskArguments?: SubtaskArguments
+  ): Promise<any>;
   isDefined: boolean;
 }
 
-export type ActionType<ArgsT extends TaskArguments> = (
-  taskArgs: ArgsT,
+export type ActionType<TaskArgumentsT extends TaskArguments> = (
+  taskArgs: TaskArgumentsT,
   env: HardhatRuntimeEnvironment,
-  runSuper: RunSuperFunction<ArgsT>
+  runSuper: RunSuperFunction<TaskArgumentsT>
 ) => Promise<any>;
 
 export interface HardhatArguments {
@@ -183,7 +190,8 @@ export interface TasksMap {
 
 export type RunTaskFunction = (
   name: string,
-  taskArguments?: TaskArguments
+  taskArguments?: TaskArguments,
+  subtaskArguments?: SubtaskArguments
 ) => Promise<any>;
 
 export interface HardhatRuntimeEnvironment {
@@ -194,6 +202,7 @@ export interface HardhatRuntimeEnvironment {
   readonly run: RunTaskFunction;
   readonly network: Network;
   readonly artifacts: Artifacts;
+  readonly version: string;
 }
 
 export interface Network {
@@ -207,9 +216,3 @@ export interface Network {
  * modify its properties or add new ones.
  */
 export type EnvironmentExtender = (env: HardhatRuntimeEnvironment) => void;
-
-/**
- * A function that receives the resolved Hardhat configuration and
- * returns an extra source of artifacts.
- */
-export type ArtifactsExtender = (config: HardhatConfig) => ArtifactsSource;

package/src/utils/source-names.ts

@@ -3,6 +3,7 @@ import path from "path";
 import { HardhatError } from "../internal/core/errors";
 import { ERRORS } from "../internal/core/errors-list";
 import { FileNotFoundError, getFileTrueCase } from "../internal/util/fs-utils";
+import { getPackageName } from "../internal/util/packageInfo";
 
 const NODE_MODULES = "node_modules";
 
@@ -228,3 +229,17 @@ async function getSourceNameTrueCase(
     throw error;
   }
 }
+
+/**
+ * This function returns true if the sourceName contains the current package's name
+ * as a substring
+ */
+export async function includesOwnPackageName(
+  sourceName: string
+): Promise<boolean> {
+  const packageName = await getPackageName(sourceName);
+  if (packageName !== "") {
+    return sourceName.startsWith(`${packageName}/`);
+  }
+  return false;
+}