hardhatjs 2.22.15

package/src/internal/util/wei-values.ts

@@ -0,0 +1,65 @@
+/**
+ * This function turns a wei value in a human readable string. It shows values
+ * in ETH, gwei or wei, depending on how large it is.
+ *
+ * It never show more than 99999 wei or gwei, moving to the larger denominator
+ * when necessary.
+ *
+ * It never shows more than 4 decimal digits. Adapting denominator and
+ * truncating as necessary.
+ */
+export function weiToHumanReadableString(wei: bigint | number): string {
+  if (typeof wei === "number") {
+    wei = BigInt(wei);
+  }
+
+  if (wei === 0n) {
+    return "0 ETH";
+  }
+
+  if (wei < 100_000n) {
+    return `${wei.toString()} wei`;
+  }
+
+  if (wei < 10n ** 14n) {
+    return `${toDecimalString(wei, 9, 4)} gwei`;
+  }
+
+  return `${toDecimalString(wei, 18, 4)} ETH`;
+}
+
+function toDecimalString(
+  value: bigint,
+  digitsToInteger: number,
+  decimalDigits: number = 4
+): string {
+  const oneUnit = 10n ** BigInt(digitsToInteger);
+  const oneDecimal = 10n ** BigInt(digitsToInteger - decimalDigits);
+
+  const integer = value / oneUnit;
+
+  const decimals = (value % oneUnit) / oneDecimal;
+  if (decimals === 0n) {
+    return integer.toString(10);
+  }
+
+  const decimalsString = removeRightZeros(
+    decimals.toString(10).padStart(decimalDigits, "0")
+  );
+
+  return `${integer.toString(10)}.${decimalsString}`;
+}
+
+function removeRightZeros(str: string): string {
+  let zeros = 0;
+
+  for (let i = str.length - 1; i >= 0; i--) {
+    if (str.charAt(i) !== "0") {
+      break;
+    }
+
+    zeros += 1;
+  }
+
+  return str.substr(0, str.length - zeros);
+}

package/src/internal/vendor/await-semaphore/index.ts

@@ -0,0 +1,66 @@
+// Based on: https://github.com/notenoughneon/await-semaphore/blob/f117a6b59324038c9e8ee04c70c328215a727812/index.ts
+// which is distributed under this license: https://github.com/notenoughneon/await-semaphore/blob/f117a6b59324038c9e8ee04c70c328215a727812/LICENSE
+
+/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
+
+export class Semaphore {
+  public count: number;
+  private _tasks: Array<() => void> = [];
+
+  constructor(count: number) {
+    this.count = count;
+  }
+
+  public acquire() {
+    return new Promise<() => void>((res) => {
+      const task = () => {
+        let released = false;
+        res(() => {
+          if (!released) {
+            released = true;
+            this.count++;
+            this._sched();
+          }
+        });
+      };
+      this._tasks.push(task);
+      if (process !== undefined && process.nextTick !== undefined) {
+        process.nextTick(this._sched.bind(this));
+      } else {
+        setImmediate(this._sched.bind(this));
+      }
+    });
+  }
+
+  public use<T>(f: () => Promise<T>) {
+    return this.acquire().then((release) => {
+      return f()
+        .then((res) => {
+          release();
+          return res;
+        })
+        .catch((err) => {
+          release();
+          throw err;
+        });
+    });
+  }
+
+  private _sched() {
+    if (this.count > 0 && this._tasks.length > 0) {
+      this.count--;
+      const next = this._tasks.shift();
+      if (next === undefined) {
+        throw new Error("Unexpected undefined value in tasks list");
+      }
+
+      next();
+    }
+  }
+}
+
+export class Mutex extends Semaphore {
+  constructor() {
+    super(1);
+  }
+}

package/src/plugins-testing.ts

@@ -0,0 +1 @@
+export { resetHardhatContext } from "./internal/reset";

package/src/plugins.ts

@@ -0,0 +1,7 @@
+export { ProviderWrapper } from "./internal/core/providers/wrapper";
+export {
+  HardhatPluginError,
+  NomicLabsHardhatPluginError,
+} from "./internal/core/errors";
+export { lazyObject, lazyFunction } from "./internal/util/lazy";
+export { HARDHAT_NETWORK_NAME } from "./internal/constants";

package/src/profiling.ts

@@ -0,0 +1,37 @@
+import { assertHardhatInvariant } from "./internal/core/errors";
+
+/**
+ * Utility to create ad-hoc profiles when computing flamegraphs. You can think
+ * of these as virtual tasks that execute the function `f`.
+ *
+ * This is an **unstable** feature, only meant for development. DO NOT use in
+ * production code nor plugins.
+ *
+ * @param name The name of the profile. Think of it as a virtual task name.
+ * @param f The function you want to profile.
+ */
+export async function adhocProfile<T>(
+  name: string,
+  f: () => Promise<T>
+): Promise<T> {
+  const globalAsAny = global as any;
+  assertHardhatInvariant(
+    "adhocProfile" in globalAsAny,
+    "adhocProfile is missing. Are you running with --flamegraph?"
+  );
+  return globalAsAny.adhocProfile(name, f);
+}
+
+/**
+ * Sync version of adhocProfile
+ *
+ * @see adhocProfile
+ */
+export function adhocProfileSync<T>(name: string, f: () => T): T {
+  const globalAsAny = global as any;
+  assertHardhatInvariant(
+    "adhocProfileSync" in globalAsAny,
+    "adhocProfileSync is missing. Are you running with --flamegraph?"
+  );
+  return globalAsAny.adhocProfileSync(name, f);
+}

package/src/register.ts

@@ -0,0 +1,54 @@
+import debug from "debug";
+
+import { HardhatContext } from "./internal/context";
+import { loadConfigAndTasks } from "./internal/core/config/config-loading";
+import { getEnvHardhatArguments } from "./internal/core/params/env-variables";
+import { HARDHAT_PARAM_DEFINITIONS } from "./internal/core/params/hardhat-params";
+import { Environment } from "./internal/core/runtime-environment";
+import {
+  loadTsNode,
+  willRunWithTypescript,
+} from "./internal/core/typescript-support";
+import {
+  disableReplWriterShowProxy,
+  isNodeCalledWithoutAScript,
+} from "./internal/util/console";
+
+if (!HardhatContext.isCreated()) {
+  require("source-map-support/register");
+
+  const ctx = HardhatContext.createHardhatContext();
+
+  if (isNodeCalledWithoutAScript()) {
+    disableReplWriterShowProxy();
+  }
+
+  const hardhatArguments = getEnvHardhatArguments(
+    HARDHAT_PARAM_DEFINITIONS,
+    process.env
+  );
+
+  if (hardhatArguments.verbose) {
+    debug.enable("hardhat*");
+  }
+
+  if (willRunWithTypescript(hardhatArguments.config)) {
+    loadTsNode(hardhatArguments.tsconfig, hardhatArguments.typecheck);
+  }
+
+  const { resolvedConfig, userConfig } = loadConfigAndTasks(hardhatArguments);
+
+  const env = new Environment(
+    resolvedConfig,
+    hardhatArguments,
+    ctx.tasksDSL.getTaskDefinitions(),
+    ctx.tasksDSL.getScopesDefinitions(),
+    ctx.environmentExtenders,
+    userConfig,
+    ctx.providerExtenders
+  );
+
+  ctx.setHardhatRuntimeEnvironment(env);
+
+  env.injectToGlobal();
+}

package/src/types/artifacts.ts

@@ -0,0 +1,252 @@
+export interface Artifacts {
+  /**
+   * Reads an artifact.
+   *
+   * @param contractNameOrFullyQualifiedName The name of the contract.
+   *   It can be a contract bare contract name (e.g. "Token") if it's
+   *   unique in your project, or a fully qualified contract name
+   *   (e.g. "contract/token.sol:Token") otherwise.
+   *
+   * @throws Throws an error if a non-unique contract name is used,
+   *   indicating which fully qualified names can be used instead.
+   */
+  readArtifact(contractNameOrFullyQualifiedName: string): Promise<Artifact>;
+
+  /**
+   * Synchronous version of readArtifact.
+   */
+  readArtifactSync(contractNameOrFullyQualifiedName: string): Artifact;
+
+  /**
+   * Returns true if an artifact exists.
+   *
+   * This function doesn't throw if the name is not unique.
+   *
+   * @param contractNameOrFullyQualifiedName Contract or fully qualified name.
+   *
+   */
+  artifactExists(contractNameOrFullyQualifiedName: string): Promise<boolean>;
+
+  /**
+   * Returns an array with the fully qualified names of all the artifacts.
+   */
+  getAllFullyQualifiedNames(): Promise<string[]>;
+
+  /**
+   * Returns the BuildInfo associated with the solc run that compiled a
+   * contract.
+   *
+   * Note that if your contract hasn't been compiled with solc this method
+   * can return undefined.
+   */
+  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.
+   *
+   * Note that there's an artifact per contract.
+   */
+  getArtifactPaths(): Promise<string[]>;
+
+  /**
+   * Returns an array with the absolute paths of all the existing debug files.
+   *
+   * Note that there's a debug file per Solidity contract.
+   */
+  getDebugFilePaths(): Promise<string[]>;
+
+  /**
+   * Returns an array with the absolute paths of all the existing build infos.
+   *
+   * Note that there's one build info per run of solc, so they can be shared
+   * by different contracts.
+   */
+  getBuildInfoPaths(): Promise<string[]>;
+
+  /**
+   * Saves a contract's artifact and debug file.
+   *
+   * @param artifact The artifact object.
+   * @param pathToBuildInfo The path to the build info from the solc run that
+   *  compiled the contract. If the contract was built with another compiler
+   *  use `undefined` and not debug file will be saved.
+   */
+  saveArtifactAndDebugFile(
+    artifact: Artifact,
+    pathToBuildInfo?: string
+  ): Promise<void>;
+
+  /**
+   * Saves the build info associated to a solc run.
+   *
+   * @param solcVersion The semver-compatible version number.
+   * @param solcLongVersion The full solc version.
+   * @param input The compiler input.
+   * @param output The compiler output.
+   */
+  saveBuildInfo(
+    solcVersion: string,
+    solcLongVersion: string,
+    input: CompilerInput,
+    output: CompilerOutput
+  ): Promise<string>;
+
+  /**
+   * Returns the absolute path to the given artifact.
+   *
+   * @param fullyQualifiedName The FQN of the artifact.
+   */
+  formArtifactPathFromFullyQualifiedName(fullyQualifiedName: string): string;
+
+  /**
+   * Starting with Hardhat 2.11.0, the artifacts object caches the information
+   * about paths that it fetches from the filesystem (e.g. the list of
+   * artifacts, the path that an artifact name resolves to, etc.). The artifacts
+   * and buildInfos themselves are not cached, only their paths.
+   *
+   * This method, if present, clears that cache.
+   */
+  clearCache?: () => void;
+
+  /**
+   * This method, if present, disables the artifact paths cache.
+   *
+   * We recommend NOT using this method. The only reason it exists is for
+   * backwards compatibility. If your app was assuming no cache, you can use it
+   * (e.g. from an HRE extender).
+   *
+   * @see clearCache
+   */
+  disableCache?: () => void;
+}
+
+/**
+ * An artifact representing the compilation output of a contract.
+ *
+ * This file has just enough information to deploy the contract and interact
+ * with an already deployed instance of it.
+ *
+ * For debugging information and other extra information, you should look for
+ * its companion DebugFile, which should be stored right next to it.
+ *
+ * Note that DebugFiles are only generated for Solidity contracts.
+ */
+export interface Artifact {
+  _format: string;
+  contractName: string;
+  sourceName: string;
+  abi: any[];
+  bytecode: string; // "0x"-prefixed hex string
+  deployedBytecode: string; // "0x"-prefixed hex string
+  linkReferences: LinkReferences;
+  deployedLinkReferences: LinkReferences;
+}
+
+/**
+ * A DebugFile contains any extra information about a Solidity contract that
+ * Hardhat and its plugins need.
+ *
+ * The current version of DebugFiles only contains a path to a BuildInfo file.
+ */
+export interface DebugFile {
+  _format: string;
+  buildInfo: string;
+}
+
+/**
+ * A BuildInfo is a file that contains all the information of a solc run. It
+ * includes all the necessary information to recreate that exact same run, and
+ * all of its output.
+ */
+export interface BuildInfo {
+  _format: string;
+  id: string;
+  solcVersion: string;
+  solcLongVersion: string;
+  input: CompilerInput;
+  output: CompilerOutput;
+}
+
+export interface LinkReferences {
+  [libraryFileName: string]: {
+    [libraryName: string]: Array<{ length: number; start: number }>;
+  };
+}
+
+export interface CompilerInput {
+  language: string;
+  sources: { [sourceName: string]: { content: string } };
+  settings: {
+    viaIR?: boolean;
+    optimizer: {
+      runs?: number;
+      enabled?: boolean;
+      details?: {
+        yulDetails: {
+          optimizerSteps: string;
+        };
+      };
+    };
+    metadata?: { useLiteralContent: boolean };
+    outputSelection: {
+      [sourceName: string]: {
+        [contractName: string]: string[];
+      };
+    };
+    evmVersion?: string;
+    libraries?: {
+      [libraryFileName: string]: {
+        [libraryName: string]: string;
+      };
+    };
+    remappings?: string[];
+  };
+}
+
+export interface CompilerOutputContract {
+  abi: any;
+  evm: {
+    bytecode: CompilerOutputBytecode;
+    deployedBytecode: CompilerOutputBytecode;
+    methodIdentifiers: {
+      [methodSignature: string]: string;
+    };
+  };
+}
+
+export interface CompilerOutput {
+  sources: CompilerOutputSources;
+  contracts: {
+    [sourceName: string]: {
+      [contractName: string]: CompilerOutputContract;
+    };
+  };
+}
+
+export interface CompilerOutputSource {
+  id: number;
+  ast: any;
+}
+
+export interface CompilerOutputSources {
+  [sourceName: string]: CompilerOutputSource;
+}
+
+export interface CompilerOutputBytecode {
+  object: string;
+  opcodes: string;
+  sourceMap: string;
+  linkReferences: {
+    [sourceName: string]: {
+      [libraryName: string]: Array<{ start: number; length: 20 }>;
+    };
+  };
+  immutableReferences?: {
+    [key: string]: Array<{ start: number; length: number }>;
+  };
+}

package/src/types/builtin-tasks/compile.ts

@@ -0,0 +1,108 @@
+import { SolcConfig } from "../config";
+
+/**
+ * A Solidity file.
+ */
+export interface ResolvedFile {
+  library?: LibraryInfo;
+  sourceName: string;
+  absolutePath: string;
+  content: FileContent;
+  // IMPORTANT: Mapped to ctime, NOT mtime. mtime isn't updated when the file
+  // properties (e.g. its name) are changed, only when it's content changes.
+  lastModificationDate: Date;
+  contentHash: string;
+  getVersionedName(): string;
+}
+
+export type ArtifactsEmittedPerFile = Array<{
+  file: ResolvedFile;
+  artifactsEmitted: string[];
+}>;
+
+/**
+ * Information about an npm library.
+ */
+export interface LibraryInfo {
+  name: string;
+  version: string;
+}
+
+/**
+ * The content of a Solidity file. Including its raw content, its imports and
+ * version pragma directives.
+ */
+export interface FileContent {
+  rawContent: string;
+  imports: string[];
+  versionPragmas: string[];
+}
+
+/**
+ * A CompilationJob includes all the necessary information to generate artifacts
+ * from a group of files. This includes those files, their dependencies, and the
+ * version and configuration of solc that should be used.
+ */
+export interface CompilationJob {
+  emitsArtifacts(file: ResolvedFile): boolean;
+  hasSolc9573Bug(): boolean;
+  merge(other: CompilationJob): CompilationJob;
+  getResolvedFiles(): ResolvedFile[];
+  getSolcConfig(): SolcConfig;
+}
+
+/**
+ * A DependencyGraph represents a group of files and how they depend on each
+ * other.
+ */
+export interface DependencyGraph {
+  getConnectedComponents(): DependencyGraph[];
+  getDependencies(file: ResolvedFile): ResolvedFile[];
+  getResolvedFiles(): ResolvedFile[];
+  getTransitiveDependencies(file: ResolvedFile): TransitiveDependency[];
+}
+
+/**
+ * Used as part of the return value of DependencyGraph.getTransitiveDependencies
+ */
+export interface TransitiveDependency {
+  dependency: ResolvedFile;
+
+  /**
+   * The list of intermediate files between the file and the dependency
+   * this is not guaranteed to be the shortest path
+   */
+  path: ResolvedFile[];
+}
+
+/**
+ * An object with a list of successfully created compilation jobs and a list of
+ * errors. The `errors` entry maps error codes (that come from the
+ * CompilationJobCreationError enum) to the source names of the files that
+ * caused that error.
+ */
+export interface CompilationJobsCreationResult {
+  jobs: CompilationJob[];
+  errors: CompilationJobCreationError[];
+}
+
+export interface CompilationJobCreationError {
+  reason: CompilationJobCreationErrorReason;
+  file: ResolvedFile;
+  extra?: any;
+}
+
+export enum CompilationJobCreationErrorReason {
+  OTHER_ERROR = "other",
+  NO_COMPATIBLE_SOLC_VERSION_FOUND = "no-compatible-solc-version-found",
+  INCOMPATIBLE_OVERRIDEN_SOLC_VERSION = "incompatible-overriden-solc-version",
+  DIRECTLY_IMPORTS_INCOMPATIBLE_FILE = "directly-imports-incompatible-file",
+  INDIRECTLY_IMPORTS_INCOMPATIBLE_FILE = "indirectly-imports-incompatible-file",
+}
+
+export interface SolcBuild {
+  version: string;
+  longVersion: string;
+  compilerPath: string;
+  isSolcJs: boolean;
+}

package/src/types/builtin-tasks/index.ts

@@ -0,0 +1,2 @@
+export * from "./compile";
+export * from "./node";

package/src/types/builtin-tasks/node.ts

@@ -0,0 +1,6 @@
+export interface JsonRpcServer {
+  listen(): Promise<{ address: string; port: number }>;
+  waitUntilClosed(): Promise<void>;
+
+  close(): Promise<void>;
+}