Be more strict about types in consoleLogger.ts and make it a static class

This makes it clearer what the exact logic is and if additional state is
used, which will be helpful when porting this code to Rust as we don't
want to rely on an external console.log decoding logic in JS.

Author: Xanewok

packages/hardhat-core/src/internal/hardhat-network/provider/provider.ts

@@ -289,10 +289,7 @@ export class EdrProviderWrapper
       },
       {
         enable: loggerConfig.enabled,
-        decodeConsoleLogInputsCallback: (inputs: Buffer[]) => {
-          const consoleLogger = new ConsoleLogger();
-          return consoleLogger.getDecodedLogs(inputs);
-        },
+        decodeConsoleLogInputsCallback: ConsoleLogger.getDecodedLogs,
         getContractAndFunctionNameCallback: (
           code: Buffer,
           calldata?: Buffer

packages/hardhat-core/src/internal/hardhat-network/stack-traces/consoleLogger.ts

@@ -50,27 +50,41 @@ import {
 
 const REGISTER_SIZE = 32;
 
-export type ConsoleLogEntry = string | ConsoleLogEntry[];
-export type ConsoleLogs = ConsoleLogEntry[];
+/** The decoded string representation of the arguments supplied to console.log */
+export type ConsoleLogArgs = string[];
+export type ConsoleLogs = ConsoleLogArgs[];
 
 export class ConsoleLogger {
   /**
    * Temporary code to print console.sol messages that come from EDR
    */
-  public getDecodedLogs(messages: Buffer[]): string[] {
+  public static getDecodedLogs(messages: Buffer[]): string[] {
     const logs: string[] = [];
 
     for (const message of messages) {
-      const log = this._maybeConsoleLog(message);
+      const log = ConsoleLogger._maybeConsoleLog(message);
       if (log !== undefined) {
-        logs.push(consoleLogToString(log));
+        logs.push(ConsoleLogger.format(log));
       }
     }
 
     return logs;
   }
 
-  private _maybeConsoleLog(calldata: Buffer): ConsoleLogs | undefined {
+  /**
+   * Returns a formatted string using the first argument as a `printf`-like
+   * format string which can contain zero or more format specifiers.
+   *
+   * If there are more arguments passed than the number of specifiers, the
+   * extra arguments are concatenated to the returned string, separated by spaces.
+   */
+  public static format(args: ConsoleLogArgs = []): string {
+    return util.format(...args);
+  }
+
+  private static _maybeConsoleLog(
+    calldata: Buffer
+  ): ConsoleLogArgs | undefined {
     const selector = bytesToInt(calldata.slice(0, 4));
     const parameters = calldata.slice(4);
 
@@ -79,15 +93,10 @@ export class ConsoleLogger {
       return;
     }
 
-    const consoleLogs = this._decode(parameters, argTypes);
-
-    this._replaceNumberFormatSpecifiers(consoleLogs);
-
-    return consoleLogs;
-  }
+    const decodedArgs = ConsoleLogger._decode(parameters, argTypes);
 
-  private _replaceNumberFormatSpecifiers(consoleLogs: ConsoleLogs) {
     /**
+     * The first argument is interpreted as the format string, which may need adjusting.
      * Replace the occurrences of %d and %i with %s. This is necessary because if the arguments passed are numbers,
      * they could be too large to be formatted as a Number or an Integer, so it is safer to use a String.
      * %d and %i are replaced only if there is an odd number of % before the d or i.
@@ -99,15 +108,18 @@ export class ConsoleLogger {
      * (?<!%) negative look-behind to make this work.
      * The (?:) is just to avoid capturing that inner group.
      */
-    if (consoleLogs.length > 0 && typeof consoleLogs[0] === "string") {
-      consoleLogs[0] = consoleLogs[0].replace(
+    if (decodedArgs.length > 0) {
+      decodedArgs[0] = decodedArgs[0].replace(
         /((?<!%)(?:%%)*)(%[di])/g,
         "$1%s"
       );
     }
+
+    return decodedArgs;
   }
 
-  private _decode(data: Buffer, types: string[]): ConsoleLogs {
+  /** Decodes parameters from `data` according to `types` into their string representation. */
+  private static _decode(data: Buffer, types: string[]): string[] {
     return types.map((type, i) => {
       const position: number = i * 32;
       switch (types[i]) {
@@ -221,16 +233,3 @@ export class ConsoleLogger {
     });
   }
 }
-
-export function consoleLogToString(log: ConsoleLogs): string {
-  if (log === undefined) {
-    return "";
-  }
-
-  // special case for console.log()
-  if (log.length === 0) {
-    return "";
-  }
-
-  return util.format(log[0], ...log.slice(1));
-}

packages/hardhat-core/test/internal/hardhat-network/stack-traces/test.ts

@@ -9,7 +9,7 @@ import { EdrProviderWrapper } from "../../../../src/internal/hardhat-network/pro
 import { ReturnData } from "../../../../src/internal/hardhat-network/provider/return-data";
 import {
   ConsoleLogs,
-  consoleLogToString,
+  ConsoleLogger,
 } from "../../../../src/internal/hardhat-network/stack-traces/consoleLogger";
 import {
   printMessageTrace,
@@ -95,7 +95,7 @@ interface DeploymentTransaction {
   };
   stackTrace?: StackFrameDescription[]; // No stack trace === the tx MUST be successful
   imports?: string[]; // Imports needed for successful compilation
-  consoleLogs?: ConsoleLogs[];
+  consoleLogs?: ConsoleLogs;
   gas?: number;
 }
 
@@ -110,7 +110,7 @@ interface CallTransaction {
   // The second one is with function and parms
   function?: string; // Default: no data
   params?: Array<string | number>; // Default: no param
-  consoleLogs?: ConsoleLogs[];
+  consoleLogs?: ConsoleLogs;
   gas?: number;
 }
 
@@ -455,7 +455,7 @@ function compareStackTraces(
   assert.lengthOf(trace, description.length);
 }
 
-function compareConsoleLogs(logs: string[], expectedLogs?: ConsoleLogs[]) {
+function compareConsoleLogs(logs: string[], expectedLogs?: ConsoleLogs) {
   if (expectedLogs === undefined) {
     return;
   }
@@ -464,7 +464,7 @@ function compareConsoleLogs(logs: string[], expectedLogs?: ConsoleLogs[]) {
 
   for (let i = 0; i < logs.length; i++) {
     const actual = logs[i];
-    const expected = consoleLogToString(expectedLogs[i]);
+    const expected = ConsoleLogger.format(expectedLogs[i]);
 
     assert.equal(actual, expected);
   }