refactor: Side-effect free utils

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