hardhat 2.15.0 → 2.16.0

package/src/builtin-tasks/node.ts

@@ -109,13 +109,10 @@ subtask(TASK_NODE_GET_PROVIDER)
       let provider = network.provider;
 
       if (network.name !== HARDHAT_NETWORK_NAME) {
-        const networkConfig = config.networks[HARDHAT_NETWORK_NAME];
-
         log(`Creating hardhat provider for JSON-RPC server`);
-        provider = createProvider(
+        provider = await createProvider(
+          config,
           HARDHAT_NETWORK_NAME,
-          networkConfig,
-          config.paths,
           artifacts
         );
       }

package/src/internal/cli/analytics.ts

@@ -3,10 +3,8 @@ import type { request as RequestT } from "undici";
 import AbortController from "abort-controller";
 import debug from "debug";
 import os from "os";
-import qs from "qs";
 import { v4 as uuid } from "uuid";
 
-import * as builtinTaskNames from "../../builtin-tasks/task-names";
 import { isLocalDev } from "../core/execution-mode";
 import { isRunningOnCiServer } from "../util/ci-detection";
 import {
@@ -19,37 +17,46 @@ import { getPackageJson } from "../util/packageInfo";
 
 const log = debug("hardhat:core:analytics");
 
-// VERY IMPORTANT:
-// The documentation doesn't say so, but the user-agent parameter is required (ua).
-// If you don't send it, you won't get an error or anything, Google will *silently* drop your hit.
-//
-// https://stackoverflow.com/questions/27357954/google-analytics-measurement-protocol-not-working
-interface RawAnalytics {
-  v: "1";
-  tid: string;
-  cid: string;
-  dp: string;
-  dh: string;
-  t: string;
-  ua: string;
-  cs: string;
-  cm: string;
-  cd1: string;
-  cd2: string;
-  cd3: string;
+/* eslint-disable @typescript-eslint/naming-convention */
+interface AnalyticsPayload {
+  client_id: string;
+  user_id: string;
+  user_properties: {
+    projectId: {
+      value?: string;
+    };
+    userType: {
+      value?: string;
+    };
+    hardhatVersion: {
+      value?: string;
+    };
+    operatingSystem: {
+      value?: string;
+    };
+    nodeVersion: {
+      value?: string;
+    };
+  };
+  events: Array<{
+    name: string;
+    params: {
+      engagement_time_msec: string;
+      session_id: string;
+    };
+  }>;
 }
+/* eslint-enable @typescript-eslint/naming-convention */
 
 type AbortAnalytics = () => void;
 
-const googleAnalyticsUrl = "https://www.google-analytics.com/collect";
-
 export class Analytics {
   public static async getInstance(telemetryConsent: boolean | undefined) {
-    const analytics: Analytics = new Analytics({
-      clientId: await getClientId(),
+    const analytics: Analytics = new Analytics(
+      await getClientId(),
       telemetryConsent,
-      userType: getUserType(),
-    });
+      getUserType()
+    );
 
     return analytics;
   }
@@ -57,22 +64,22 @@ export class Analytics {
   private readonly _clientId: string;
   private readonly _enabled: boolean;
   private readonly _userType: string;
-  // Hardhat's tracking id. I guess there's no other choice than keeping it here.
-  private readonly _trackingId: string = "UA-117668706-3";
-
-  private constructor({
-    clientId,
-    telemetryConsent,
-    userType,
-  }: {
-    clientId: string;
-    telemetryConsent: boolean | undefined;
-    userType: string;
-  }) {
+  private readonly _analyticsUrl: string =
+    "https://www.google-analytics.com/mp/collect";
+  private readonly _apiSecret: string = "fQ5joCsDRTOp55wX8a2cVw";
+  private readonly _measurementId: string = "G-8LQ007N2QJ";
+  private _sessionId: string;
+
+  private constructor(
+    clientId: string,
+    telemetryConsent: boolean | undefined,
+    userType: string
+  ) {
     this._clientId = clientId;
     this._enabled =
       !isLocalDev() && !isRunningOnCiServer() && telemetryConsent === true;
     this._userType = userType;
+    this._sessionId = Math.random().toString();
   }
 
   /**
@@ -83,106 +90,70 @@ export class Analytics {
    *
    * Trying to abort a successfully completed request is a no-op, so it's always safe to call it.
    *
-   * @param taskName The name of the task to be logged
-   *
    * @returns The abort function
    */
-  public async sendTaskHit(
-    taskName: string
-  ): Promise<[AbortAnalytics, Promise<void>]> {
-    if (this._isABuiltinTaskName(taskName)) {
-      taskName = "builtin";
-    } else {
-      taskName = "custom";
-    }
-
+  public async sendTaskHit(): Promise<[AbortAnalytics, Promise<void>]> {
     if (!this._enabled) {
       return [() => {}, Promise.resolve()];
     }
 
-    return this._sendHit(await this._taskHit(taskName));
+    return this._sendHit(await this._buildTaskHitPayload());
   }
 
-  private _isABuiltinTaskName(taskName: string) {
-    return Object.values<string>(builtinTaskNames).includes(taskName);
-  }
-
-  private async _taskHit(taskName: string): Promise<RawAnalytics> {
+  private async _buildTaskHitPayload(): Promise<AnalyticsPayload> {
     return {
-      // Measurement protocol version.
-      v: "1",
-
-      // Hit type, we're only using pageviews for now.
-      t: "pageview",
-
-      // Hardhat's tracking Id.
-      tid: this._trackingId,
-
-      // Client Id.
-      cid: this._clientId,
-
-      // Document path, must start with a '/'.
-      dp: `/task/${taskName}`,
-
-      // Host name.
-      dh: "cli.hardhat.org",
-
-      // User agent, must be present.
-      // We use it to inform Node version used and OS.
-      // Example:
-      //   Node/v8.12.0 (Darwin 17.7.0)
-      ua: getUserAgent(),
-
-      // We're using the following values (Campaign source, Campaign medium) to track
-      // whether the user is a Developer or CI, as Custom Dimensions are not working for us atm.
-      cs: this._userType,
-      cm: "User Type",
-
-      // We're using custom dimensions for tracking different user projects, and user types (Developer/CI).
-      //
-      // See the following link for docs on these paremeters:
-      // https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters#pr_cd_
-      //
-      // See the following link for setting up our custom dimensions in the Google Analytics dashboard
-      // https://support.google.com/tagmanager/answer/6164990
-      //
-      // Custom dimension 1: Project Id
-      cd1: "hardhat-project",
-      // Custom dimension 2: User type
-      //   Possible values: "CI", "Developer".
-      cd2: this._userType,
-      // Custom dimension 3: Hardhat Version
-      //   Example: "Hardhat 1.0.0".
-      cd3: await getHardhatVersion(),
+      client_id: this._clientId,
+      user_id: this._clientId,
+      user_properties: {
+        projectId: { value: "hardhat-project" },
+        userType: { value: this._userType },
+        hardhatVersion: { value: await getHardhatVersion() },
+        operatingSystem: { value: os.platform() },
+        nodeVersion: { value: process.version },
+      },
+      events: [
+        {
+          name: "task",
+          params: {
+            // From the GA docs: amount of time someone spends with your web
+            // page in focus or app screen in the foreground
+            // The parameter has no use for our app, but it's required in order
+            // for user activity to display in standard reports like Realtime
+            engagement_time_msec: "10000",
+            session_id: this._sessionId,
+          },
+        },
+      ],
     };
   }
 
-  private _sendHit(hit: RawAnalytics): [AbortAnalytics, Promise<void>] {
+  private _sendHit(payload: AnalyticsPayload): [AbortAnalytics, Promise<void>] {
     const { request } = require("undici") as { request: typeof RequestT };
-
-    log(`Sending hit for ${hit.dp}`);
+    const eventName = payload.events[0].name;
+    log(`Sending hit for ${eventName}`);
 
     const controller = new AbortController();
 
     const abortAnalytics = () => {
-      log(`Aborting hit for ${JSON.stringify(hit.dp)}`);
+      log(`Aborting hit for ${eventName}`);
 
       controller.abort();
     };
 
-    const hitPayload = qs.stringify(hit);
+    log(`Hit payload: ${JSON.stringify(payload)}`);
 
-    log(`Hit payload: ${JSON.stringify(hit)}`);
-
-    const hitPromise = request(googleAnalyticsUrl, {
-      body: hitPayload,
+    const hitPromise = request(this._analyticsUrl, {
+      query: {
+        api_secret: this._apiSecret,
+        measurement_id: this._measurementId,
+      },
+      body: JSON.stringify(payload),
       method: "POST",
       signal: controller.signal,
     })
       .then(() => {
-        log(`Hit for ${JSON.stringify(hit.dp)} sent successfully`);
+        log(`Hit for ${eventName} sent successfully`);
       })
-      // We're not really interested in handling failed analytics requests
       .catch(() => {
         log("Hit request failed");
       });
@@ -214,29 +185,6 @@ function getUserType(): string {
   return isRunningOnCiServer() ? "CI" : "Developer";
 }
 
-/**
- * At the moment, we couldn't find a reliably way to report the OS () in Node,
- * as the versions reported by the various `os` APIs (`os.platform()`, `os.type()`, etc)
- * return values different to those expected by Google Analytics
- * We decided to take the compromise of just reporting the OS Platform (OSX/Linux/Windows) for now (version information is bogus for now).
- */
-function getOperatingSystem(): string {
-  switch (os.type()) {
-    case "Windows_NT":
-      return "(Windows NT 6.1; Win64; x64)";
-    case "Darwin":
-      return "(Macintosh; Intel Mac OS X 10_13_6)";
-    case "Linux":
-      return "(X11; Linux x86_64)";
-    default:
-      return "(Unknown)";
-  }
-}
-
-function getUserAgent(): string {
-  return `Node/${process.version} ${getOperatingSystem()}`;
-}
-
 async function getHardhatVersion(): Promise<string> {
   const { version } = await getPackageJson();
 

package/src/internal/cli/cli.ts

@@ -212,7 +212,8 @@ async function main() {
       telemetryConsent === undefined &&
       !isHelpCommand &&
       !isRunningOnCiServer() &&
-      process.stdout.isTTY === true
+      process.stdout.isTTY === true &&
+      process.env.HARDHAT_DISABLE_TELEMETRY_PROMPT !== "true"
     ) {
       telemetryConsent = await confirmTelemetryConsent();
 
@@ -228,10 +229,11 @@ async function main() {
       Reporter.setEnabled(true);
     }
 
-    const envExtenders = ctx.extendersManager.getExtenders();
+    const envExtenders = ctx.environmentExtenders;
+    const providerExtenders = ctx.providerExtenders;
     const taskDefinitions = ctx.tasksDSL.getTaskDefinitions();
 
-    const [abortAnalytics, hitPromise] = await analytics.sendTaskHit(taskName);
+    const [abortAnalytics, hitPromise] = await analytics.sendTaskHit();
 
     let taskArguments: TaskArguments;
 
@@ -266,7 +268,8 @@ async function main() {
       taskDefinitions,
       envExtenders,
       ctx.experimentalHardhatNetworkMessageTraceHooks,
-      userConfig
+      userConfig,
+      providerExtenders
     );
 
     ctx.setHardhatRuntimeEnvironment(env);

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

@@ -403,7 +403,10 @@ export async function createProject() {
     await addGitIgnore(projectRoot);
   }
 
-  if (hasConsentedTelemetry() === undefined) {
+  if (
+    process.env.HARDHAT_DISABLE_TELEMETRY_PROMPT !== "true" &&
+    hasConsentedTelemetry() === undefined
+  ) {
     const telemetryConsent = await confirmTelemetryConsent();
 
     if (telemetryConsent !== undefined) {

package/src/internal/context.ts

@@ -1,10 +1,11 @@
 import {
   ConfigExtender,
+  EnvironmentExtender,
   ExperimentalHardhatNetworkMessageTraceHook,
   HardhatRuntimeEnvironment,
+  ProviderExtender,
 } from "../types";
 
-import { ExtenderManager } from "./core/config/extenders";
 import { assertHardhatInvariant, HardhatError } from "./core/errors";
 import { ERRORS } from "./core/errors-list";
 import { TasksDSL } from "./core/tasks/dsl";
@@ -45,8 +46,10 @@ export class HardhatContext {
   }
 
   public readonly tasksDSL = new TasksDSL();
-  public readonly extendersManager = new ExtenderManager();
+  public readonly environmentExtenders: EnvironmentExtender[] = [];
   public environment?: HardhatRuntimeEnvironment;
+  public readonly providerExtenders: ProviderExtender[] = [];
+
   public readonly configExtenders: ConfigExtender[] = [];
 
   // NOTE: This is experimental and will be removed. Please contact our team if

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

@@ -4,6 +4,7 @@ import {
   ConfigurableTaskDefinition,
   EnvironmentExtender,
   ExperimentalHardhatNetworkMessageTraceHook,
+  ProviderExtender,
   TaskArguments,
 } from "../../../types";
 import { HardhatContext } from "../../context";
@@ -126,15 +127,33 @@ export const types = argumentTypes;
  */
 export function extendEnvironment(extender: EnvironmentExtender) {
   const ctx = HardhatContext.getHardhatContext();
-  const extenderManager = ctx.extendersManager;
-  extenderManager.add(extender);
+  ctx.environmentExtenders.push(extender);
 }
 
+/**
+ * Register a config extender what will be run after the
+ * Hardhat Runtime Environment is initialized.
+ *
+ * @param extender A function that receives the resolved config
+ * to be modified and the config provided by the user
+ */
 export function extendConfig(extender: ConfigExtender) {
   const ctx = HardhatContext.getHardhatContext();
   ctx.configExtenders.push(extender);
 }
 
+/**
+ * Register a provider extender what will be run after the
+ * Hardhat Runtime Environment is initialized.
+ *
+ * @param extender A function that receives the current provider
+ * and returns a new one.
+ */
+export function extendProvider(extender: ProviderExtender) {
+  const ctx = HardhatContext.getHardhatContext();
+  ctx.providerExtenders.push(extender);
+}
+
 // 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/errors-list.ts

@@ -269,6 +269,15 @@ Rename the file to use the .cjs to fix this problem.`,
       description: `Your project is an ESM project (you have "type": "module" set in your package.json) and you are trying to initialize a TypeScript project. This is not supported yet.`,
       shouldBeReported: false,
     },
+    UNINITIALIZED_PROVIDER: {
+      number: 21,
+      message:
+        "You tried to access an uninitialized provider. To initialize the provider, make sure you first call `.init()` or any method that hits a node like request, send or sendAsync.",
+      title: "Uninitialized provider",
+      description: `You tried to access an uninitialized provider. This is most likely caused by using the internal wrapped provider directly before using it to send a request or initializing it.
+To initialize the provider, make sure you first call \`.init()\` or any method that hits a node like request, send or sendAsync.`,
+      shouldBeReported: true,
+    },
   },
   NETWORK: {
     CONFIG_NOT_FOUND: {

package/src/internal/core/providers/construction.ts

@@ -3,12 +3,13 @@ import type {
   BoundExperimentalHardhatNetworkMessageTraceHook,
   EIP1193Provider,
   EthereumProvider,
+  HardhatConfig,
   HardhatNetworkConfig,
   HDAccountsUserConfig,
   HttpNetworkAccountsUserConfig,
   HttpNetworkConfig,
   NetworkConfig,
-  ProjectPathsConfig,
+  ProviderExtender,
 } from "../../../types";
 
 import type {
@@ -46,14 +47,16 @@ function importProvider<ModuleT, ProviderNameT extends keyof ModuleT>(
   return mod[name];
 }
 
-export function createProvider(
+export async function createProvider(
+  config: HardhatConfig,
   networkName: string,
-  networkConfig: NetworkConfig,
-  paths?: ProjectPathsConfig,
   artifacts?: Artifacts,
-  experimentalHardhatNetworkMessageTraceHooks: BoundExperimentalHardhatNetworkMessageTraceHook[] = []
-): EthereumProvider {
+  experimentalHardhatNetworkMessageTraceHooks: BoundExperimentalHardhatNetworkMessageTraceHook[] = [],
+  extenders: ProviderExtender[] = []
+): Promise<EthereumProvider> {
   let eip1193Provider: EIP1193Provider;
+  const networkConfig = config.networks[networkName];
+  const paths = config.paths;
 
   if (networkName === HARDHAT_NETWORK_NAME) {
     const hardhatNetConfig = networkConfig as HardhatNetworkConfig;
@@ -132,7 +135,17 @@ export function createProvider(
     );
   }
 
-  const wrappedProvider = applyProviderWrappers(eip1193Provider, networkConfig);
+  let wrappedProvider = eip1193Provider;
+
+  for (const extender of extenders) {
+    wrappedProvider = await extender(wrappedProvider, config, networkName);
+  }
+
+  wrappedProvider = applyProviderWrappers(
+    wrappedProvider,
+    networkConfig,
+    extenders
+  );
 
   const BackwardsCompatibilityProviderAdapter = importProvider<
     typeof import("./backwards-compatibility"),
@@ -144,7 +157,8 @@ export function createProvider(
 
 export function applyProviderWrappers(
   provider: EIP1193Provider,
-  netConfig: Partial<NetworkConfig>
+  netConfig: Partial<NetworkConfig>,
+  extenders: ProviderExtender[]
 ): EIP1193Provider {
   // These dependencies are lazy-loaded because they are really big.
   const LocalAccountsProvider = importProvider<
@@ -226,8 +240,10 @@ export function applyProviderWrappers(
     // fields, as the missing ones will be resolved there.
     //
     // Hardhat Network handles this in a more performant way, so we don't use
-    // the AutomaticGasPriceProvider for it.
-    if (isResolvedHttpNetworkConfig(netConfig)) {
+    // the AutomaticGasPriceProvider for it unless there are provider extenders.
+    // The reason for this is that some extenders (like hardhat-ledger's) might
+    // do the signing themselves, and that needs the gas price to be set.
+    if (isResolvedHttpNetworkConfig(netConfig) || extenders.length > 0) {
       provider = new AutomaticGasPriceProvider(provider);
     }
   } else {