hardhatjs 2.22.15

package/src/internal/core/errors.ts

@@ -0,0 +1,274 @@
+import { getClosestCallerPackage } from "../util/caller-package";
+import { replaceAll } from "../util/strings";
+
+import { ErrorDescriptor, ERRORS, getErrorCode } from "./errors-list";
+
+const inspect = Symbol.for("nodejs.util.inspect.custom");
+
+export class CustomError extends Error {
+  private _stack: string;
+
+  constructor(message: string, public readonly parent?: Error) {
+    // WARNING: Using super when extending a builtin class doesn't work well
+    // with TS if you are compiling to a version of JavaScript that doesn't have
+    // native classes. We don't do that in Hardhat.
+    //
+    // For more info about this, take a look at: https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
+    super(message);
+
+    this.name = this.constructor.name;
+
+    // We do this to avoid including the constructor in the stack trace
+    if ((Error as any).captureStackTrace !== undefined) {
+      (Error as any).captureStackTrace(this, this.constructor);
+    }
+
+    this._stack = this.stack ?? "";
+
+    Object.defineProperty(this, "stack", {
+      get: () => this[inspect](),
+    });
+  }
+
+  public [inspect](): string {
+    let str = this._stack;
+    if (this.parent !== undefined) {
+      const parentAsAny = this.parent as any;
+      const causeString =
+        parentAsAny[inspect]?.() ??
+        parentAsAny.inspect?.() ??
+        parentAsAny.stack ??
+        parentAsAny.toString();
+      const nestedCauseStr = causeString
+        .split("\n")
+        .map((line: string) => `    ${line}`)
+        .join("\n")
+        .trim();
+      str += `
+
+    Caused by: ${nestedCauseStr}`;
+    }
+    return str;
+  }
+}
+
+export class HardhatError extends CustomError {
+  public static isHardhatError(other: any): other is HardhatError {
+    return (
+      other !== undefined && other !== null && other._isHardhatError === true
+    );
+  }
+
+  public static isHardhatErrorType(
+    other: any,
+    descriptor: ErrorDescriptor
+  ): other is HardhatError {
+    return (
+      HardhatError.isHardhatError(other) &&
+      other.errorDescriptor.number === descriptor.number
+    );
+  }
+
+  public readonly errorDescriptor: ErrorDescriptor;
+  public readonly number: number;
+  public readonly messageArguments: Record<string, any>;
+
+  private readonly _isHardhatError: boolean;
+
+  constructor(
+    errorDescriptor: ErrorDescriptor,
+    messageArguments: Record<string, string | number> = {},
+    parentError?: Error
+  ) {
+    const prefix = `${getErrorCode(errorDescriptor)}: `;
+
+    const formattedMessage = applyErrorMessageTemplate(
+      errorDescriptor.message,
+      messageArguments
+    );
+
+    super(prefix + formattedMessage, parentError);
+
+    this.errorDescriptor = errorDescriptor;
+    this.number = errorDescriptor.number;
+    this.messageArguments = messageArguments;
+
+    this._isHardhatError = true;
+    Object.setPrototypeOf(this, HardhatError.prototype);
+  }
+}
+
+/**
+ * This class is used to throw errors from hardhat plugins made by third parties.
+ */
+export class HardhatPluginError extends CustomError {
+  public static isHardhatPluginError(other: any): other is HardhatPluginError {
+    return (
+      other !== undefined &&
+      other !== null &&
+      other._isHardhatPluginError === true
+    );
+  }
+
+  public readonly pluginName: string;
+
+  private readonly _isHardhatPluginError: boolean;
+
+  /**
+   * Creates a HardhatPluginError.
+   *
+   * @param pluginName The name of the plugin.
+   * @param message An error message that will be shown to the user.
+   * @param parent The error that causes this error to be thrown.
+   */
+  constructor(pluginName: string, message: string, parent?: Error);
+
+  /**
+   * A DEPRECATED constructor that automatically obtains the caller package and
+   * use it as plugin name.
+   *
+   * @deprecated Use the above constructor.
+   *
+   * @param message An error message that will be shown to the user.
+   * @param parent The error that causes this error to be thrown.
+   */
+  constructor(message: string, parent?: Error);
+
+  constructor(
+    pluginNameOrMessage: string,
+    messageOrParent?: string | Error,
+    parent?: Error
+  ) {
+    if (typeof messageOrParent === "string") {
+      super(messageOrParent, parent);
+      this.pluginName = pluginNameOrMessage;
+    } else {
+      super(pluginNameOrMessage, messageOrParent);
+      this.pluginName = getClosestCallerPackage()!;
+    }
+
+    this._isHardhatPluginError = true;
+    Object.setPrototypeOf(this, HardhatPluginError.prototype);
+  }
+}
+
+export class NomicLabsHardhatPluginError extends HardhatPluginError {
+  public static isNomicLabsHardhatPluginError(
+    other: any
+  ): other is NomicLabsHardhatPluginError {
+    return (
+      other !== undefined &&
+      other !== null &&
+      other._isNomicLabsHardhatPluginError === true
+    );
+  }
+
+  private readonly _isNomicLabsHardhatPluginError: boolean;
+
+  /**
+   * This class is used to throw errors from *core* hardhat plugins. If you are
+   * developing a third-party plugin, use HardhatPluginError instead.
+   */
+  constructor(
+    pluginName: string,
+    message: string,
+    parent?: Error,
+    public shouldBeReported = false
+  ) {
+    super(pluginName, message, parent);
+
+    this._isNomicLabsHardhatPluginError = true;
+    Object.setPrototypeOf(this, NomicLabsHardhatPluginError.prototype);
+  }
+}
+
+/**
+ * This function applies error messages templates like this:
+ *
+ *  - Template is a string which contains a variable tags. A variable tag is a
+ *    a variable name surrounded by %. Eg: %plugin1%
+ *  - A variable name is a string of alphanumeric ascii characters.
+ *  - Every variable tag is replaced by its value.
+ *  - %% is replaced by %.
+ *  - Values can't contain variable tags.
+ *  - If a variable is not present in the template, but present in the values
+ *    object, an error is thrown.
+ *
+ * @param template The template string.
+ * @param values A map of variable names to their values.
+ */
+export function applyErrorMessageTemplate(
+  template: string,
+  values: { [templateVar: string]: any }
+): string {
+  return _applyErrorMessageTemplate(template, values, false);
+}
+
+function _applyErrorMessageTemplate(
+  template: string,
+  values: { [templateVar: string]: any },
+  isRecursiveCall: boolean
+): string {
+  if (!isRecursiveCall) {
+    for (const variableName of Object.keys(values)) {
+      if (variableName.match(/^[a-zA-Z][a-zA-Z0-9]*$/) === null) {
+        throw new HardhatError(ERRORS.INTERNAL.TEMPLATE_INVALID_VARIABLE_NAME, {
+          variable: variableName,
+        });
+      }
+
+      const variableTag = `%${variableName}%`;
+
+      if (!template.includes(variableTag)) {
+        throw new HardhatError(ERRORS.INTERNAL.TEMPLATE_VARIABLE_TAG_MISSING, {
+          variable: variableName,
+        });
+      }
+    }
+  }
+
+  if (template.includes("%%")) {
+    return template
+      .split("%%")
+      .map((part) => _applyErrorMessageTemplate(part, values, true))
+      .join("%");
+  }
+
+  for (const variableName of Object.keys(values)) {
+    let value: string;
+
+    if (values[variableName] === undefined) {
+      value = "undefined";
+    } else if (values[variableName] === null) {
+      value = "null";
+    } else {
+      value = values[variableName].toString();
+    }
+
+    if (value === undefined) {
+      value = "undefined";
+    }
+
+    const variableTag = `%${variableName}%`;
+
+    if (value.match(/%([a-zA-Z][a-zA-Z0-9]*)?%/) !== null) {
+      throw new HardhatError(
+        ERRORS.INTERNAL.TEMPLATE_VALUE_CONTAINS_VARIABLE_TAG,
+        { variable: variableName }
+      );
+    }
+
+    template = replaceAll(template, variableTag, value);
+  }
+
+  return template;
+}
+
+export function assertHardhatInvariant(
+  invariant: boolean,
+  message: string
+): asserts invariant {
+  if (!invariant) {
+    throw new HardhatError(ERRORS.GENERAL.ASSERTION_ERROR, { message });
+  }
+}

package/src/internal/core/execution-mode.ts

@@ -0,0 +1,39 @@
+import { getPackageJsonPath } from "../util/packageInfo";
+import { getRealPathSync } from "../util/fs-utils";
+
+/**
+ * Returns true if Hardhat is installed locally or linked from its repository,
+ * by looking for it using the node module resolution logic.
+ *
+ * If a config file is provided, we start looking for it from it. Otherwise,
+ * we use the current working directory.
+ */
+export function isHardhatInstalledLocallyOrLinked(configPath?: string) {
+  try {
+    const resolvedPackageJson = require.resolve("hardhat/package.json", {
+      paths: [configPath ?? process.cwd()],
+    });
+
+    const thisPackageJson = getPackageJsonPath();
+
+    // We need to get the realpaths here, as hardhat may be linked and
+    // running with `node --preserve-symlinks`
+    return (
+      getRealPathSync(resolvedPackageJson) === getRealPathSync(thisPackageJson)
+    );
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Checks whether we're using Hardhat in development mode (that is, we're working _on_ Hardhat).
+ */
+export function isLocalDev(): boolean {
+  // TODO: This may give a false positive under yarn PnP
+  return isRunningHardhatCoreTests() || !__filename.includes("node_modules");
+}
+
+export function isRunningHardhatCoreTests(): boolean {
+  return __filename.endsWith(".ts");
+}

package/src/internal/core/flamegraph.ts

@@ -0,0 +1,270 @@
+import fs from "fs";
+import { assertHardhatInvariant } from "./errors";
+import { flagParallelChildren, TaskProfile } from "./task-profiling";
+
+export interface Flamegraph {
+  name: string;
+  value: number;
+  children: Flamegraph[];
+  parallel: boolean;
+}
+
+export function profileToFlamegraph(profile: TaskProfile): Flamegraph {
+  assertHardhatInvariant(
+    profile.end !== undefined,
+    `Formatting invalid task profile for ${profile.name}. No end was recorded.`
+  );
+
+  return {
+    name: profile.name,
+    // We assume this is a safe int, which is ok unless a task runs for months
+    value: Number(profile.end - profile.start),
+    children: profile.children.map((c) => profileToFlamegraph(c)),
+    parallel: profile.parallel === true,
+  };
+}
+
+/**
+ * Merges compatible children of toFold and its children.
+ *
+ * Compatible in a traditional Flamegraph means having the same name. We
+ * modified that notion and also require their `parallel` flag to have the same
+ * value. This means that parallel and non-parallel calls to the same function
+ * are shown with two Flamegraph "blocks".
+ *
+ * The parallel block shows the max running time, instead of the sum of them.
+ **/
+function foldFramegraph(toFold: Flamegraph): Flamegraph {
+  if (toFold.children.length === 0) {
+    return {
+      name: toFold.name,
+      value: toFold.value,
+      children: [],
+      parallel: toFold.parallel,
+    };
+  }
+
+  const children = toFold.children.map((c) => foldFramegraph(c));
+  children.sort((a, b) =>
+    a.parallel === b.parallel ? 0 : b.parallel ? -1 : 1
+  );
+  children.sort((a, b) => a.name.localeCompare(b.name));
+
+  const foldedChildren = [children[0]];
+  const mergedChildren = new Set<number>();
+  for (let i = 1; i < children.length; i++) {
+    const latest = foldedChildren[foldedChildren.length - 1];
+    if (
+      children[i].name === latest.name &&
+      children[i].parallel === latest.parallel
+    ) {
+      if (latest.parallel) {
+        latest.value = Math.max(latest.value, children[i].value);
+      } else {
+        latest.value += children[i].value;
+      }
+
+      latest.children.push(...children[i].children);
+      mergedChildren.add(foldedChildren.length - 1);
+    } else {
+      foldedChildren.push(children[i]);
+    }
+  }
+
+  for (const i of mergedChildren.values()) {
+    foldedChildren[i] = foldFramegraph(foldedChildren[i]);
+  }
+
+  return {
+    name: toFold.name,
+    value: toFold.value,
+    children: foldedChildren,
+    parallel: toFold.parallel,
+  };
+}
+
+export function createFlamegraphHtmlFile(flamegraph: Flamegraph): string {
+  const content = getFlamegraphFileContent(foldFramegraph(flamegraph));
+  const path = "flamegraph.html";
+
+  fs.writeFileSync(path, content, { encoding: "utf8" });
+
+  return path;
+}
+
+function getFlamegraphFileContent(flamegraph: Flamegraph): string {
+  const data = JSON.stringify(foldFramegraph(flamegraph), undefined, 2);
+  return `<!-- Based on d3-flamegraph's example. See its license in: https://github.com/spiermar/d3-flame-graph/blob/master/LICENSE -->
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+
+    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="https://cdn.jsdelivr.net/gh/spiermar/d3-flame-graph@2.0.3/dist/d3-flamegraph.css">
+
+    <style>
+    /* Space out content a bit */
+    body {
+      padding-top: 20px;
+      padding-bottom: 20px;
+    }
+
+    /* Custom page header */
+    .header {
+      padding-bottom: 20px;
+      padding-right: 15px;
+      padding-left: 15px;
+      border-bottom: 1px solid #e5e5e5;
+    }
+
+    /* Make the masthead heading the same height as the navigation */
+    .header h3 {
+      margin-top: 0;
+      margin-bottom: 0;
+      line-height: 40px;
+    }
+
+    /* Customize container */
+    .container {
+      max-width: 990px;
+    }
+    </style>
+
+    <title>Hardhat task flamegraph</title>
+  </head>
+  <body>
+    <div class="container">
+      <div class="header clearfix">
+        <nav>
+          <div class="pull-right">
+            <form class="form-inline" id="form">
+              <a class="btn" href="javascript: resetZoom();">Reset zoom</a>
+              <a class="btn" href="javascript: clear();">Clear</a>
+              <div class="form-group">
+                <input type="text" class="form-control" id="term">
+              </div>
+              <a class="btn btn-primary" href="javascript: search();">Search</a>
+            </form>
+          </div>
+        </nav>
+        <h3 class="text-muted">Hardhat task flamegraph</h3>
+      </div>
+      <div id="chart">
+      </div>
+      <hr>
+      <div id="details">
+      </div>
+    </div>
+
+    <!-- D3.js -->
+    <script src="https://d3js.org/d3.v4.min.js" charset="utf-8"></script>
+
+    <!-- d3-tip -->
+    <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/d3-tip/0.9.1/d3-tip.min.js"></script>
+
+    <!-- d3-flamegraph -->
+    <script type="text/javascript" src="https://cdn.jsdelivr.net/gh/spiermar/d3-flame-graph@2.0.3/dist/d3-flamegraph.min.js"></script>
+
+    <script type="text/javascript">
+    const flameGraph = d3.flamegraph()
+      .width(960)
+      .cellHeight(18)
+      .transitionDuration(750)
+      .minFrameSize(5)
+      .transitionEase(d3.easeCubic)
+      .sort(true)
+      .title("")
+      .onClick(onClick)
+      .differential(false)
+      .selfValue(false);
+
+    function label(d) {
+      if (d.data.parallel) {
+        return "(multiple parallel runs) task: " + d.data.name + ", max time: " + readableTime(d.data.value);
+      }
+
+      return "task: " + d.data.name + ", time: " + readableTime(d.data.value);
+    }
+
+    function readableTime(t) {
+      const NANOSECONDS_TO_MILLISECONDS = 1_000_000;
+      const NANOSECONDS_TO_SECONDS = 1_000_000_000;
+
+      if (t < NANOSECONDS_TO_MILLISECONDS) {
+        return t + "ns";
+      }
+
+      if (t < NANOSECONDS_TO_SECONDS) {
+          return (t / NANOSECONDS_TO_MILLISECONDS).toFixed(4) + "ms";
+      }
+
+      return (t / NANOSECONDS_TO_SECONDS).toFixed(4) + "s";
+    }
+
+    const tip = d3.tip()
+      .direction("s")
+      .offset([8, 0])
+      .attr('class', 'd3-flame-graph-tip')
+      .html(label);
+
+    flameGraph.tooltip(tip);
+
+    const details = document.getElementById("details");
+    flameGraph.setDetailsElement(details);
+
+    flameGraph.label(label);
+
+    flameGraph.setColorMapper(function(d, originalColor) {
+      if (d.highlight) {
+        return '#E600E6';
+      }
+
+      if (d.data.parallel) {
+        return '#1478eb'
+      }
+
+      return "#EB5414"
+    });
+
+    d3.select("#chart")
+          .datum(${data})
+          .call(flameGraph);
+
+    document.getElementById("form").addEventListener("submit", function(event){
+      event.preventDefault();
+      search();
+    });
+
+    function search() {
+      const term = document.getElementById("term").value;
+      flameGraph.search(term);
+    }
+
+    function clear() {
+      document.getElementById('term').value = '';
+      flameGraph.clear();
+    }
+
+    function resetZoom() {
+      flameGraph.resetZoom();
+    }
+
+    function onClick(d) {
+      console.info("Clicked on " + d.data.name);
+    }
+    </script>
+  </body>
+</html>
+`;
+}
+
+/**
+ * Converts the TaskProfile into a flamegraph, saves it, and returns its path.
+ */
+export function saveFlamegraph(profile: TaskProfile): string {
+  flagParallelChildren(profile);
+  const flamegraph = profileToFlamegraph(profile);
+  return createFlamegraphHtmlFile(flamegraph);
+}

package/src/internal/core/jsonrpc/types/access-list.ts

@@ -0,0 +1,16 @@
+import * as t from "io-ts";
+
+import { nullable } from "../../../util/io-ts";
+
+import { rpcData } from "./base-types";
+
+const rpcAccessListTuple = t.type({
+  address: rpcData,
+  storageKeys: nullable(t.array(rpcData)),
+});
+
+export const rpcAccessList = t.array(rpcAccessListTuple);
+
+export type RpcAccessListTuple = t.TypeOf<typeof rpcAccessListTuple>;
+
+export type RpcAccessList = t.TypeOf<typeof rpcAccessList>;