hardhat 2.13.0-dev.0 → 2.13.0-dev.2

package/src/internal/artifacts/readonly.ts

@@ -0,0 +1,470 @@
+import * as os from "os";
+import * as path from "path";
+
+import fsExtra from "fs-extra";
+
+import { Artifact, BuildInfo } from "../../types";
+import {
+  getFullyQualifiedName,
+  isFullyQualifiedName,
+  parseFullyQualifiedName,
+  findDistance,
+} from "../../utils/contract-names";
+import { replaceBackslashes } from "../../utils/source-names";
+
+import { BUILD_INFO_DIR_NAME, EDIT_DISTANCE_THRESHOLD } from "../constants";
+import { HardhatError } from "../core/errors";
+import { ERRORS } from "../core/errors-list";
+import {
+  FileNotFoundError,
+  getAllFilesMatching,
+  getAllFilesMatchingSync,
+  getFileTrueCase,
+  getFileTrueCaseSync,
+} from "../util/fs-utils";
+
+/**
+ * The purpose of this class is to encapsulate JSON file I/O. It assumes that
+ * all input strings are simply paths, not contract names nor fully-qualified
+ * contract names like other interfaces around here accept.
+ */
+class ReadOnlyByPath {
+  protected async _readArtifactByPath(artifactPath: string): Promise<Artifact> {
+    return fsExtra.readJson(artifactPath);
+  }
+
+  protected _readArtifactByPathSync(artifactPath: string): Artifact {
+    return fsExtra.readJsonSync(artifactPath);
+  }
+
+  protected async _artifactPathExists(artifactPath: string): Promise<boolean> {
+    return fsExtra.pathExists(artifactPath);
+  }
+
+  protected async _getBuildInfoByPath(
+    buildInfoPath: string
+  ): Promise<BuildInfo | undefined> {
+    return fsExtra.readJSON(buildInfoPath);
+  }
+
+  protected _getBuildInfoByPathSync(
+    buildInfoPath: string
+  ): BuildInfo | undefined {
+    return fsExtra.readJSONSync(buildInfoPath);
+  }
+
+  /**
+   * Given the path to a debug file, returns the absolute path to its
+   * corresponding build info file if it exists, or undefined otherwise.
+   */
+  protected static async _getBuildInfoFromDebugFile(
+    debugFilePath: string
+  ): Promise<string | undefined> {
+    if (await fsExtra.pathExists(debugFilePath)) {
+      const { buildInfo } = await fsExtra.readJson(debugFilePath);
+      return path.resolve(path.dirname(debugFilePath), buildInfo);
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Synchronous version of _getBuildInfoFromDebugFile
+   */
+  protected static _getBuildInfoFromDebugFileSync(
+    debugFilePath: string
+  ): string | undefined {
+    if (fsExtra.pathExistsSync(debugFilePath)) {
+      const { buildInfo } = fsExtra.readJsonSync(debugFilePath);
+      return path.resolve(path.dirname(debugFilePath), buildInfo);
+    }
+
+    return undefined;
+  }
+
+  protected _getDebugFilePath(artifactPath: string): string {
+    return artifactPath.replace(/\.json$/, ".dbg.json");
+  }
+}
+
+/**
+ * This class takes responsibility for the mappings between contract names,
+ * fully-qualified contract names, and file paths.
+ */
+export class ReadOnlySource extends ReadOnlyByPath {
+  constructor(protected _artifactsPath: string) {
+    super();
+  }
+
+  public async artifactExists(name: string): Promise<boolean> {
+    const artifactPath = await this._getArtifactPath(name);
+
+    if (artifactPath === undefined) {
+      return false;
+    }
+
+    return super._artifactPathExists(artifactPath);
+  }
+
+  public async getArtifactPaths(): Promise<string[]> {
+    const buildInfosDir = path.join(this._artifactsPath, BUILD_INFO_DIR_NAME);
+
+    const paths = await getAllFilesMatching(
+      this._artifactsPath,
+      (f) =>
+        f.endsWith(".json") &&
+        !f.startsWith(buildInfosDir) &&
+        !f.endsWith(".dbg.json")
+    );
+
+    return paths.sort();
+  }
+
+  /**
+   * Returns the absolute path to the given artifact
+   */
+  public formArtifactPathFromFullyQualifiedName(
+    fullyQualifiedName: string
+  ): string {
+    const { sourceName, contractName } =
+      parseFullyQualifiedName(fullyQualifiedName);
+
+    return path.join(this._artifactsPath, sourceName, `${contractName}.json`);
+  }
+
+  public async getAllFullyQualifiedNames(): Promise<string[]> {
+    const paths = await this.getArtifactPaths();
+    return paths.map((p) => this._getFullyQualifiedNameFromPath(p)).sort();
+  }
+
+  public async getBuildInfo(
+    fullyQualifiedName: string
+  ): Promise<BuildInfo | undefined> {
+    const buildInfoPath = await this._getBuildInfoPath(fullyQualifiedName);
+
+    if (buildInfoPath === undefined) {
+      return undefined;
+    }
+
+    return super._getBuildInfoByPath(buildInfoPath);
+  }
+
+  public async getBuildInfoPaths(): Promise<string[]> {
+    const paths = await getAllFilesMatching(
+      path.join(this._artifactsPath, BUILD_INFO_DIR_NAME),
+      (f) => f.endsWith(".json")
+    );
+
+    return paths.sort();
+  }
+
+  public async getDebugFilePaths(): Promise<string[]> {
+    const paths = await getAllFilesMatching(
+      path.join(this._artifactsPath),
+      (f) => f.endsWith(".dbg.json")
+    );
+
+    return paths.sort();
+  }
+
+  public async readArtifact(name: string): Promise<Artifact | undefined> {
+    const artifactPath = await this._getArtifactPath(name);
+    if (artifactPath === undefined) {
+      return undefined;
+    }
+
+    return super._readArtifactByPath(artifactPath);
+  }
+
+  public readArtifactSync(name: string): Artifact | undefined {
+    const artifactPath = this._getArtifactPathSync(name);
+    if (artifactPath === undefined) {
+      return undefined;
+    }
+
+    return super._readArtifactByPathSync(artifactPath);
+  }
+
+  public getSuggestions(name: string): string[] {
+    if (isFullyQualifiedName(name)) {
+      const fqns = this._getAllFullyQualifiedNamesSync();
+
+      return ReadOnlySource._getSimilarContractNames(name, fqns);
+    }
+
+    const files = this._getArtifactPathsSync();
+    const names = this._getAllContractNamesFromFiles(files);
+
+    let similarNames = ReadOnlySource._getSimilarContractNames(name, names);
+
+    if (similarNames.length > 1) {
+      similarNames = this._filterDuplicatesAsFullyQualifiedNames(
+        files,
+        similarNames
+      );
+    }
+
+    return similarNames;
+  }
+
+  /**
+   * If the project has these contracts:
+   *   - 'contracts/Greeter.sol:Greeter'
+   *   - 'contracts/Meeter.sol:Greeter'
+   *   - 'contracts/Greater.sol:Greater'
+   *  And the user tries to get an artifact with the name 'Greter', then
+   *  the suggestions will be 'Greeter', 'Greeter', and 'Greater'.
+   *
+   * We don't want to show duplicates here, so we use FQNs for those. The
+   * suggestions will then be:
+   *   - 'contracts/Greeter.sol:Greeter'
+   *   - 'contracts/Meeter.sol:Greeter'
+   *   - 'Greater'
+   */
+  private _filterDuplicatesAsFullyQualifiedNames(
+    files: string[],
+    similarNames: string[]
+  ): string[] {
+    const outputNames = [];
+    const groups = similarNames.reduce((obj, cur) => {
+      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+      obj[cur] = obj[cur] ? obj[cur] + 1 : 1;
+      return obj;
+    }, {} as { [k: string]: number });
+
+    for (const [name, occurrences] of Object.entries(groups)) {
+      if (occurrences > 1) {
+        for (const file of files) {
+          if (path.basename(file) === `${name}.json`) {
+            outputNames.push(this._getFullyQualifiedNameFromPath(file));
+          }
+        }
+        continue;
+      }
+
+      outputNames.push(name);
+    }
+
+    return outputNames;
+  }
+
+  private _getAllContractNamesFromFiles(files: string[]): string[] {
+    return files.map((file) => {
+      const fqn = this._getFullyQualifiedNameFromPath(file);
+      return parseFullyQualifiedName(fqn).contractName;
+    });
+  }
+
+  private _getAllFullyQualifiedNamesSync(): string[] {
+    const paths = this._getArtifactPathsSync();
+    return paths.map((p) => this._getFullyQualifiedNameFromPath(p)).sort();
+  }
+
+  /**
+   * Returns the absolute path to the artifact that corresponds to the given
+   * name.
+   *
+   * If the name is fully qualified, the path is computed from it.  If not, an
+   * artifact that matches the given name is searched in the existing artifacts.
+   * If there is an ambiguity, an error is thrown.
+   */
+  protected async _getArtifactPath(name: string): Promise<string | undefined> {
+    let result: string | undefined;
+    if (isFullyQualifiedName(name)) {
+      result = await this._getValidArtifactPathFromFullyQualifiedName(name);
+    } else {
+      const files = await this.getArtifactPaths();
+      result = this._getArtifactPathFromFiles(name, files);
+    }
+    return result;
+  }
+
+  protected _getArtifactPathSync(name: string): string | undefined {
+    let result: string | undefined;
+    if (isFullyQualifiedName(name)) {
+      result = this._getValidArtifactPathFromFullyQualifiedNameSync(name);
+    } else {
+      const files = this._getArtifactPathsSync();
+      result = this._getArtifactPathFromFiles(name, files);
+    }
+    return result;
+  }
+
+  private _getArtifactPathFromFiles(
+    contractName: string,
+    files: string[]
+  ): string | undefined {
+    const matchingFiles = files.filter((file) => {
+      return path.basename(file) === `${contractName}.json`;
+    });
+
+    if (matchingFiles.length === 0) {
+      return undefined;
+    }
+
+    if (matchingFiles.length > 1) {
+      const candidates = matchingFiles.map((file) =>
+        this._getFullyQualifiedNameFromPath(file)
+      );
+
+      throw new HardhatError(ERRORS.ARTIFACTS.MULTIPLE_FOUND, {
+        contractName,
+        candidates: candidates.join(os.EOL),
+      });
+    }
+
+    return matchingFiles[0];
+  }
+
+  protected _getArtifactPathsSync(): string[] {
+    const buildInfosDir = path.join(this._artifactsPath, BUILD_INFO_DIR_NAME);
+
+    const paths = getAllFilesMatchingSync(
+      this._artifactsPath,
+      (f) =>
+        f.endsWith(".json") &&
+        !f.startsWith(buildInfosDir) &&
+        !f.endsWith(".dbg.json")
+    );
+
+    return paths.sort();
+  }
+
+  protected async _getBuildInfoPath(
+    fullyQualifiedName: string
+  ): Promise<string | undefined> {
+    const artifactPath =
+      this.formArtifactPathFromFullyQualifiedName(fullyQualifiedName);
+
+    const debugFilePath = this._getDebugFilePath(artifactPath);
+    const buildInfoPath = await ReadOnlySource._getBuildInfoFromDebugFile(
+      debugFilePath
+    );
+    return buildInfoPath;
+  }
+
+  protected _getBuildInfoPathSync(
+    fullyQualifiedName: string
+  ): string | undefined {
+    const artifactPath =
+      this.formArtifactPathFromFullyQualifiedName(fullyQualifiedName);
+
+    const debugFilePath = this._getDebugFilePath(artifactPath);
+    const buildInfoPath =
+      ReadOnlySource._getBuildInfoFromDebugFileSync(debugFilePath);
+    return buildInfoPath;
+  }
+
+  /**
+   * Returns the FQN of a contract giving the absolute path to its artifact.
+   *
+   * For example, given a path like
+   * `/path/to/project/artifacts/contracts/Foo.sol/Bar.json`, it'll return the
+   * FQN `contracts/Foo.sol:Bar`
+   */
+  private _getFullyQualifiedNameFromPath(absolutePath: string): string {
+    const sourceName = replaceBackslashes(
+      path.relative(this._artifactsPath, path.dirname(absolutePath))
+    );
+
+    const contractName = path.basename(absolutePath).replace(".json", "");
+
+    return getFullyQualifiedName(sourceName, contractName);
+  }
+
+  /**
+   *
+   * @param givenName can be FQN or contract name
+   * @param names MUST match type of givenName (i.e. array of FQN's if givenName is FQN)
+   * @returns
+   */
+  private static _getSimilarContractNames(
+    givenName: string,
+    names: string[]
+  ): string[] {
+    let shortestDistance = EDIT_DISTANCE_THRESHOLD;
+    let mostSimilarNames: string[] = [];
+    for (const name of names) {
+      const distance = findDistance(givenName, name);
+
+      if (distance < shortestDistance) {
+        shortestDistance = distance;
+        mostSimilarNames = [name];
+        continue;
+      }
+
+      if (distance === shortestDistance) {
+        mostSimilarNames.push(name);
+        continue;
+      }
+    }
+
+    return mostSimilarNames;
+  }
+
+  private async _getValidArtifactPathFromFullyQualifiedName(
+    fullyQualifiedName: string
+  ): Promise<string | undefined> {
+    const artifactPath =
+      this.formArtifactPathFromFullyQualifiedName(fullyQualifiedName);
+
+    try {
+      const trueCasePath = path.join(
+        this._artifactsPath,
+        await getFileTrueCase(
+          this._artifactsPath,
+          path.relative(this._artifactsPath, artifactPath)
+        )
+      );
+
+      if (artifactPath !== trueCasePath) {
+        throw new HardhatError(ERRORS.ARTIFACTS.WRONG_CASING, {
+          correct: this._getFullyQualifiedNameFromPath(trueCasePath),
+          incorrect: fullyQualifiedName,
+        });
+      }
+
+      return trueCasePath;
+    } catch (e) {
+      if (e instanceof FileNotFoundError) {
+        return undefined;
+      }
+
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw e;
+    }
+  }
+
+  private _getValidArtifactPathFromFullyQualifiedNameSync(
+    fullyQualifiedName: string
+  ): string | undefined {
+    const artifactPath =
+      this.formArtifactPathFromFullyQualifiedName(fullyQualifiedName);
+
+    try {
+      const trueCasePath = path.join(
+        this._artifactsPath,
+        getFileTrueCaseSync(
+          this._artifactsPath,
+          path.relative(this._artifactsPath, artifactPath)
+        )
+      );
+
+      if (artifactPath !== trueCasePath) {
+        throw new HardhatError(ERRORS.ARTIFACTS.WRONG_CASING, {
+          correct: this._getFullyQualifiedNameFromPath(trueCasePath),
+          incorrect: fullyQualifiedName,
+        });
+      }
+
+      return trueCasePath;
+    } catch (e) {
+      if (e instanceof FileNotFoundError) {
+        return undefined;
+      }
+
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw e;
+    }
+  }
+}

package/src/internal/cli/cli.ts

@@ -39,7 +39,7 @@ import { saveFlamegraph } from "../core/flamegraph";
 import { Analytics } from "./analytics";
 import { ArgumentsParser } from "./ArgumentsParser";
 import { enableEmoji } from "./emoji";
-import { createProject } from "./project-creation";
+import { createProject, showSoliditySurveyMessage } from "./project-creation";
 import { confirmHHVSCodeInstallation, confirmTelemetryConsent } from "./prompt";
 import {
   InstallationState,
@@ -171,7 +171,11 @@ async function main() {
       }
     }
 
-    if (!isHardhatInstalledLocallyOrLinked()) {
+    if (
+      process.env.HARDHAT_EXPERIMENTAL_ALLOW_NON_LOCAL_INSTALLATION !==
+        "true" &&
+      !isHardhatInstalledLocallyOrLinked()
+    ) {
       throw new HardhatError(ERRORS.GENERAL.NON_LOCAL_INSTALLATION);
     }
 
@@ -223,7 +227,7 @@ async function main() {
       Reporter.setEnabled(true);
     }
 
-    const envExtenders = ctx.extendersManager.getExtenders();
+    const envExtenders = ctx.extendersManager.getEnvironmentExtenders();
     const taskDefinitions = ctx.tasksDSL.getTaskDefinitions();
 
     const [abortAnalytics, hitPromise] = await analytics.sendTaskHit(taskName);
@@ -255,11 +259,16 @@ async function main() {
       );
     }
 
+    const artifactsExtensions = ctx.extendersManager
+      .getArtifactsExtenders()
+      .map((artifactsExtender) => artifactsExtender(resolvedConfig));
+
     const env = new Environment(
       resolvedConfig,
       hardhatArguments,
       taskDefinitions,
       envExtenders,
+      artifactsExtensions,
       ctx.experimentalHardhatNetworkMessageTraceHooks,
       userConfig
     );
@@ -301,6 +310,16 @@ async function main() {
       process.stdout.isTTY === true
     ) {
       await suggestInstallingHardhatVscode();
+
+      // we show the solidity survey message if the tests failed and only
+      // 1/3 of the time
+      if (
+        process.exitCode !== 0 &&
+        Math.random() < 0.3333 &&
+        process.env.HARDHAT_HIDE_SOLIDITY_SURVEY_MESSAGE !== "true"
+      ) {
+        showSoliditySurveyMessage();
+      }
     }
 
     log(`Killing Hardhat after successfully running task ${taskName}`);

package/src/internal/cli/project-creation.ts

@@ -138,7 +138,7 @@ async function copySampleProject(
       "this file already exists",
       "these files already exist"
     )}: ${existingFiles.join(", ")}
-    
+
 Please delete or move them and try again.`;
     console.log(chalk.red(errorMsg));
     process.exit(1);
@@ -252,6 +252,20 @@ function showStarOnGitHubMessage() {
   console.log(chalk.cyan("     https://github.com/NomicFoundation/hardhat"));
 }
 
+export function showSoliditySurveyMessage() {
+  if (new Date() > new Date("2023-07-01 23:39")) {
+    // the survey has finished
+    return;
+  }
+
+  console.log();
+  console.log(
+    chalk.cyan(
+      "Please take a moment to complete the 2022 Solidity Survey: https://hardhat.org/solidity-survey-2022"
+    )
+  );
+}
+
 export async function createProject() {
   printAsciiLogo();
 
@@ -287,6 +301,7 @@ export async function createProject() {
 
     console.log();
     showStarOnGitHubMessage();
+    showSoliditySurveyMessage();
 
     return;
   }
@@ -387,6 +402,7 @@ export async function createProject() {
   console.log("See the README.md file for some example tasks you can run");
   console.log();
   showStarOnGitHubMessage();
+  showSoliditySurveyMessage();
 }
 
 async function canInstallRecommendedDeps() {

package/src/internal/core/config/config-env.ts

@@ -1,5 +1,6 @@
 import {
   ActionType,
+  ArtifactsExtender,
   ConfigExtender,
   ConfigurableTaskDefinition,
   EnvironmentExtender,
@@ -127,7 +128,7 @@ export const types = argumentTypes;
 export function extendEnvironment(extender: EnvironmentExtender) {
   const ctx = HardhatContext.getHardhatContext();
   const extenderManager = ctx.extendersManager;
-  extenderManager.add(extender);
+  extenderManager.addEnvironmentExtender(extender);
 }
 
 export function extendConfig(extender: ConfigExtender) {
@@ -135,6 +136,17 @@ export function extendConfig(extender: ConfigExtender) {
   ctx.configExtenders.push(extender);
 }
 
+/**
+ * Accepts a function that receives the resolved configuration and returns an
+ * extra source of artifacts. This source has to implement the ArtifactsSource
+ * interface.
+ */
+export function extendArtifacts(artifactsExtender: ArtifactsExtender) {
+  const ctx = HardhatContext.getHardhatContext();
+  const extenderManager = ctx.extendersManager;
+  extenderManager.addArtifactsExtender(artifactsExtender);
+}
+
 // NOTE: This is experimental and will be removed. Please contact our team
 // if you are planning to use it.
 export function experimentalAddHardhatNetworkMessageTraceHook(

package/src/internal/core/config/config-resolution.ts

@@ -408,9 +408,10 @@ function resolveCompiler(compiler: SolcUserConfig): SolcConfig {
       }
 
       for (const output of outputs) {
-        if (
-          !resolved.settings.outputSelection[file][contract].includes(output)
-        ) {
+        const includesOutput: boolean =
+          resolved.settings.outputSelection[file][contract].includes(output);
+
+        if (!includesOutput) {
           resolved.settings.outputSelection[file][contract].push(output);
         }
       }

package/src/internal/core/config/extenders.ts

@@ -1,13 +1,22 @@
-import { EnvironmentExtender } from "../../../types";
+import { ArtifactsExtender, EnvironmentExtender } from "../../../types";
 
 export class ExtenderManager {
-  private readonly _extenders: EnvironmentExtender[] = [];
+  private readonly _environmentExtenders: EnvironmentExtender[] = [];
+  private readonly _artifactsExtenders: ArtifactsExtender[] = [];
 
-  public add(extender: EnvironmentExtender) {
-    this._extenders.push(extender);
+  public addEnvironmentExtender(environmentExtender: EnvironmentExtender) {
+    this._environmentExtenders.push(environmentExtender);
   }
 
-  public getExtenders(): EnvironmentExtender[] {
-    return this._extenders;
+  public addArtifactsExtender(artifactsExtender: ArtifactsExtender) {
+    this._artifactsExtenders.push(artifactsExtender);
+  }
+
+  public getEnvironmentExtenders(): EnvironmentExtender[] {
+    return this._environmentExtenders;
+  }
+
+  public getArtifactsExtenders(): ArtifactsExtender[] {
+    return this._artifactsExtenders;
   }
 }