refactor: Side-effect free utils (#3322)

This pull request refactors and improves utility modules in the
codebase, focusing on the `Logger` and `SigningUtil` classes, as well as
minor optimizations in binary utilities and error handling. The main
changes include a redesign of the logger initialization for better
encapsulation, simplification of the signing utility instantiation
logic, and minor performance and correctness tweaks.

> [!NOTE]
> This is just the first step (alongside the recent `utils`
refactoring). Other packages will follow to make the whole thing much
more convenient to use.

## Changes

**Logger improvements:**
- Refactored the `Logger` class to encapsulate the root logger
initialization in a static method, removing the global `rootLogger`
variable and improving encapsulation. The logger now lazily initializes
the root logger as needed.
[[1]](diffhunk://#diff-312c84735c8ba55bd72f753e86af89e6c8f1b058ac23ac2290d447c64b7fd6d4L33-R68)
[[2]](diffhunk://#diff-312c84735c8ba55bd72f753e86af89e6c8f1b058ac23ac2290d447c64b7fd6d4L54-L78)
[[3]](diffhunk://#diff-312c84735c8ba55bd72f753e86af89e6c8f1b058ac23ac2290d447c64b7fd6d4L91-R99)
- Improved the logger method wrapping logic to ensure consistent logging
behavior in browser environments.
[[1]](diffhunk://#diff-312c84735c8ba55bd72f753e86af89e6c8f1b058ac23ac2290d447c64b7fd6d4L33-R68)
[[2]](diffhunk://#diff-312c84735c8ba55bd72f753e86af89e6c8f1b058ac23ac2290d447c64b7fd6d4L54-L78)

**Signing utility simplification:**
- Simplified the `SigningUtil.getInstance` method by replacing the
static `keyTypeToInstance` map with a switch statement that directly
instantiates the correct class for each key type. This removes
unnecessary static instances and clarifies the instantiation logic.
[[1]](diffhunk://#diff-264c1a909477860ce2ed2c73f193874422c99397476f8d74ec602ccd11b80512L34-L38)
[[2]](diffhunk://#diff-264c1a909477860ce2ed2c73f193874422c99397476f8d74ec602ccd11b80512L318-L326)

**Utility optimizations:**
- Updated `binaryUtils.ts` to create new `TextEncoder` and `TextDecoder`
instances on each call instead of using shared instances, preventing
potential state issues and improving reliability.

**Error handling improvements:**
- Moved the creation of the logger instance inside the
`executeSafePromise` function to ensure a fresh logger is used for each
invocation, and removed the unnecessary top-level logger instance.

## Future steps

* Propagate the same technique throughout the other packages.

Author: mondoreale

packages/utils/src/Logger.ts

@@ -30,31 +30,6 @@ function isJestRunning(): boolean {
     return env.JEST_WORKER_ID !== undefined
 }
 
-const rootLogger = pino({
-    name: 'rootLogger',
-    enabled: !env.NOLOG,
-    level: env.LOG_LEVEL ?? 'info',
-    formatters: {
-        level: (label) => {
-            return { level: label } // log level as string instead of number
-        }
-    },
-    transport: isPrettyPrintDisabled() ? undefined : {
-        target: 'pino-pretty',
-        options: {
-            colorize: parseBoolean(env.LOG_COLORS) ?? true,
-            singleLine: true,
-            translateTime: 'yyyy-mm-dd"T"HH:MM:ss.l',
-            ignore: 'pid,hostname',
-            levelFirst: true,
-            sync: isJestRunning(),
-        },
-    },
-    browser: {
-        asObject: true
-    }
-})
-
 /**
  * This whole monstrosity exists only because pino in browser environment will not print a log message
  * when invoking `logger.info(undefined, 'msg') instead you need to call `logger.info(msg)`.
@@ -76,6 +51,39 @@ export type LoggerModule = string | { id: string }
 export class Logger {
     static NAME_LENGTH = 25
 
+    private static rootLogger: pino.Logger | undefined
+
+    private static getRootLogger(): pino.Logger {
+        Logger.rootLogger ??= pino({
+            name: 'rootLogger',
+            enabled: !env.NOLOG,
+            level: env.LOG_LEVEL ?? 'info',
+            formatters: {
+                level: (label) => {
+                    return { level: label } // log level as string instead of number
+                },
+            },
+            transport: isPrettyPrintDisabled()
+                ? undefined
+                : {
+                    target: 'pino-pretty',
+                    options: {
+                        colorize: parseBoolean(env.LOG_COLORS) ?? true,
+                        singleLine: true,
+                        translateTime: 'yyyy-mm-dd"T"HH:MM:ss.l',
+                        ignore: 'pid,hostname',
+                        levelFirst: true,
+                        sync: isJestRunning(),
+                    },
+                },
+            browser: {
+                asObject: true,
+            },
+        })
+
+        return Logger.rootLogger
+    }
+
     private readonly logger: pino.Logger
     fatal: (msg: string, metadata?: Record<string, unknown>) => void
     error: (msg: string, metadata?: Record<string, unknown>) => void
@@ -88,7 +96,7 @@ export class Logger {
         loggerModule: LoggerModule,
         contextBindings?: Record<string, unknown>,
         defaultLogLevel: LogLevel = 'info',
-        parentLogger: pino.Logger = rootLogger
+        parentLogger: pino.Logger = Logger.getRootLogger()
     ) {
         this.logger = parentLogger.child({
             name: Logger.createName(loggerModule),

packages/utils/src/SigningUtil.ts

@@ -31,11 +31,16 @@ export abstract class SigningUtil {
     abstract assertValidKeyPair(publicKey: UserIDRaw, privateKey: Uint8Array): void
 
     static getInstance(type: KeyType): SigningUtil {
-        const util = keyTypeToInstance[type]
-        if (!util) {
-            throw new Error(`Unknown key pair type: ${type}`)
+        switch (type) {
+            case 'ECDSA_SECP256K1_EVM':
+                return new EcdsaSecp256k1Evm()
+            case 'ECDSA_SECP256R1':
+                return new EcdsaSecp256r1()
+            case 'ML_DSA_87':
+                return new MlDsa87()
+            default:
+                throw new Error(`Unknown key pair type: ${type}`)
         }
-        return util
     }
 }
 
@@ -315,13 +320,4 @@ export class MlDsa87 extends SigningUtil {
             throw new Error(`The given ML-DSA public key and private key don't match!`)
         }
     }
-
-}
-
-// Declared at the bottom of the file because the classes need to be
-// declared first. TS makes sure all KeyPairTypes are present.
-const keyTypeToInstance: Record<KeyType, SigningUtil> = {
-    ECDSA_SECP256K1_EVM: new EcdsaSecp256k1Evm(),
-    ECDSA_SECP256R1: new EcdsaSecp256r1(),
-    ML_DSA_87: new MlDsa87()
 }

packages/utils/src/binaryUtils.ts

@@ -1,12 +1,9 @@
-const textEncoder = new TextEncoder()
-const textDecoder = new TextDecoder()
-
 export const binaryToUtf8 = (bytes: Uint8Array): string => {
-    return textDecoder.decode(bytes)
+    return new TextDecoder().decode(bytes)
 }
 
 export const utf8ToBinary = (utf8: string): Uint8Array => {
-    return textEncoder.encode(utf8)
+    return new TextEncoder().encode(utf8)
 }
 
 export const binaryToHex = (bytes: Uint8Array, addPrefix = false): string => {

packages/utils/src/executeSafePromise.ts

@@ -1,17 +1,17 @@
 import { Logger } from './Logger'
 
-const logger = new Logger('executeSafePromise')
-
 /**
  * Execute a promise that should never reject. If it does, log the error and exit the process
  * (in Node/Electron) or throw an unhandled error (in browsers).
  * To be used in places where we want to "annotate" that the intention of a promise is never
  * to reject (unless something is really wrong).
  */
 export const executeSafePromise = async <T>(createPromise: () => Promise<T>): Promise<T> => {
+    
     try {
         return await createPromise()
     } catch (err: any) {
+        const logger = new Logger('executeSafePromise')
         logger.fatal('Assertion failure!', { message: err?.message, err })
 
         // Check if we're in a Node/Electron environment