@typeberry/jam 0.1.1-e48de40 → 0.1.1

package/importer/index.js

@@ -4436,34 +4436,6 @@ class WithDebug {
     }
 }
 
-;// CONCATENATED MODULE: ./packages/core/utils/dev.ts
-const dev_env = typeof process === "undefined" ? {} : process.env;
-/**
- * The function will produce relative path resolver that is adjusted
- * for package location within the workspace.
- *
- * Example:
- * $ npm start -w @typeberry/jam
- *
- * The above command will run `./bin/jam/index.js`, however we would
- * still want relative paths to be resolved according to top-level workspace
- * directory.
- *
- * So the caller, passes the absolute workspace path as argument and get's
- * a function that can properly resolve relative paths.
- *
- * NOTE: the translation happens only for development build! When
- * we build a single library from our project, we no longer mangle the paths.
- */
-const workspacePathFix = dev_env.NODE_ENV === "development"
-    ? (workspacePath) => (p) => {
-        if (p.startsWith("/")) {
-            return p;
-        }
-        return `${workspacePath}/${p}`;
-    }
-    : () => (p) => p;
-
 ;// CONCATENATED MODULE: ./packages/core/utils/opaque.ts
 /**
  * @fileoverview `Opaque<Type, Token>` constructs a unique type which is a subset of Type with a
@@ -4807,7 +4779,6 @@ function isResult(x) {
 
 
 
-
 ;// CONCATENATED MODULE: ./packages/core/bytes/bitvec.ts
 
 /**
@@ -13401,23 +13372,6 @@ function parseLevel(lvl) {
 ;// CONCATENATED MODULE: ./packages/core/logger/console.ts
 // biome-ignore-all lint/suspicious/noConsole: logger
 
-function print(level, levelAndName, strings, data) {
-    if (level < levelAndName[0]) {
-        return;
-    }
-    const lvlText = Level[level].padEnd(5);
-    const val = strings.map((v, idx) => `${v}${data[idx]}`);
-    const msg = `${lvlText} [${levelAndName[1]}] ${val}`;
-    if (level === Level.WARN) {
-        console.warn(msg);
-    }
-    else if (level === Level.ERROR) {
-        console.error(msg);
-    }
-    else {
-        console.info(msg);
-    }
-}
 /** An optimized logger that ignores `TRACE`, `DEBUG` and `LOG` messages.
  *
  * Use the `create` method to instantiate the right instance of a more specialized logger.
@@ -13448,91 +13402,109 @@ class ConsoleTransport {
     constructor(options) {
         this.options = options;
     }
-    insane(_levelAndName, _strings, _data) {
+    insane(_moduleName, _val) {
         /* no-op */
     }
-    trace(_levelAndName, _strings, _data) {
+    trace(_moduleName, _val) {
         /* no-op */
     }
-    log(_levelAndName, _strings, _data) {
+    log(_moduleName, _val) {
         /* no-op */
     }
-    info(_levelAndName, _strings, _data) {
+    info(_moduleName, _val) {
         /* no-op */
     }
-    warn(levelAndName, strings, data) {
-        print(Level.WARN, levelAndName, strings, data);
+    warn(moduleName, val) {
+        this.push(Level.WARN, moduleName, val);
     }
-    error(levelAndName, strings, data) {
-        print(Level.ERROR, levelAndName, strings, data);
+    error(moduleName, val) {
+        this.push(Level.ERROR, moduleName, val);
+    }
+    push(level, moduleName, val) {
+        const shortModule = moduleName.replace(this.options.workingDir, "");
+        const configuredLevel = findLevel(this.options, moduleName);
+        const lvlText = Level[level].padEnd(5);
+        if (level < configuredLevel) {
+            return;
+        }
+        const msg = `${lvlText} [${shortModule}] ${val}`;
+        if (level === Level.WARN) {
+            console.warn(msg);
+        }
+        else if (level === Level.ERROR) {
+            console.error(msg);
+        }
+        else {
+            console.info(msg);
+        }
     }
 }
 /**
  * Insane version of console logger - supports insane level.
  */
 class InsaneConsoleLogger extends ConsoleTransport {
-    insane(levelAndName, strings, data) {
-        print(Level.INSANE, levelAndName, strings, data);
+    insane(moduleName, val) {
+        this.push(Level.INSANE, moduleName, val);
     }
-    trace(levelAndName, strings, data) {
-        print(Level.TRACE, levelAndName, strings, data);
+    trace(moduleName, val) {
+        this.push(Level.TRACE, moduleName, val);
     }
-    log(levelAndName, strings, data) {
-        print(Level.LOG, levelAndName, strings, data);
+    log(moduleName, val) {
+        this.push(Level.LOG, moduleName, val);
     }
-    info(levelAndName, strings, data) {
-        print(Level.INFO, levelAndName, strings, data);
+    info(moduleName, val) {
+        this.push(Level.INFO, moduleName, val);
     }
 }
 /**
  * A basic version of console logger - printing everything.
  */
 class TraceConsoleTransport extends ConsoleTransport {
-    insane(_levelAndName, _strings, _data) {
+    insane(_moduleName, _val) {
         /* no-op */
     }
-    trace(levelAndName, strings, data) {
-        print(Level.TRACE, levelAndName, strings, data);
+    trace(moduleName, val) {
+        this.push(Level.TRACE, moduleName, val);
     }
-    log(levelAndName, strings, data) {
-        print(Level.LOG, levelAndName, strings, data);
+    log(moduleName, val) {
+        this.push(Level.LOG, moduleName, val);
     }
-    info(levelAndName, strings, data) {
-        print(Level.INFO, levelAndName, strings, data);
+    info(moduleName, val) {
+        this.push(Level.INFO, moduleName, val);
     }
 }
 /**
  * An optimized version of the logger - completely ignores `TRACE` level calls.
  */
 class LogConsoleTransport extends ConsoleTransport {
-    insane(_levelAndName, _strings, _data) {
+    insane(_moduleName, _val) {
         /* no-op */
     }
-    trace(_levelAndName, _strings, _data) {
+    trace(_moduleName, _val) {
         /* no-op */
     }
-    log(levelAndName, strings, data) {
-        print(Level.LOG, levelAndName, strings, data);
+    log(moduleName, val) {
+        this.push(Level.LOG, moduleName, val);
     }
-    info(levelAndName, strings, data) {
-        print(Level.INFO, levelAndName, strings, data);
+    info(moduleName, val) {
+        this.push(Level.INFO, moduleName, val);
     }
 }
 /**
  * An optimized version of the logger - completely ignores `TRACE` & `DEBUG` level calls.
  */
 class InfoConsoleTransport extends ConsoleTransport {
-    insane(_levelAndName, _strings, _data) {
+    insane(_moduleName, _val) {
         /* no-op */
     }
-    trace(_levelAndName, _strings, _data) {
+    trace(_moduleName, _val) {
         /* no-op */
     }
-    log(_levelAndName, _strings, _data) {
+    log(_moduleName, _val) {
         /* no-op */
     }
-    info(levelAndName, strings, data) {
-        print(Level.INFO, levelAndName, strings, data);
+    info(moduleName, val) {
+        this.push(Level.INFO, moduleName, val);
     }
 }
 
@@ -13569,6 +13541,11 @@ class Logger {
         const module = moduleName ?? fName;
         return new Logger(module.padStart(8, " "), GLOBAL_CONFIG);
     }
+    /**
+     * Return currently configured level for given module. */
+    static getLevel(moduleName) {
+        return findLevel(GLOBAL_CONFIG.options, moduleName);
+    }
     /**
      * Global configuration of all loggers.
      *
@@ -13599,46 +13576,33 @@ class Logger {
         const options = parseLoggerOptions(input, defaultLevel, workingDir);
         Logger.configureAllFromOptions(options);
     }
-    cachedLevelAndName;
     constructor(moduleName, config) {
         this.moduleName = moduleName;
         this.config = config;
     }
-    /** Return currently configured level for given module. */
-    getLevel() {
-        return this.getLevelAndName()[0];
-    }
-    getLevelAndName() {
-        if (this.cachedLevelAndName === undefined) {
-            const level = findLevel(this.config.options, this.moduleName);
-            const shortName = this.moduleName.replace(this.config.options.workingDir, "");
-            this.cachedLevelAndName = [level, shortName];
-        }
-        return this.cachedLevelAndName;
-    }
     /** Log a message with `INSANE` level. */
-    insane(strings, ...data) {
-        this.config.transport.insane(this.getLevelAndName(), strings, data);
+    insane(val) {
+        this.config.transport.insane(this.moduleName, val);
     }
     /** Log a message with `TRACE` level. */
-    trace(strings, ...data) {
-        this.config.transport.trace(this.getLevelAndName(), strings, data);
+    trace(val) {
+        this.config.transport.trace(this.moduleName, val);
     }
     /** Log a message with `DEBUG`/`LOG` level. */
-    log(strings, ...data) {
-        this.config.transport.log(this.getLevelAndName(), strings, data);
+    log(val) {
+        this.config.transport.log(this.moduleName, val);
     }
     /** Log a message with `INFO` level. */
-    info(strings, ...data) {
-        this.config.transport.info(this.getLevelAndName(), strings, data);
+    info(val) {
+        this.config.transport.info(this.moduleName, val);
     }
     /** Log a message with `WARN` level. */
-    warn(strings, ...data) {
-        this.config.transport.warn(this.getLevelAndName(), strings, data);
+    warn(val) {
+        this.config.transport.warn(this.moduleName, val);
     }
     /** Log a message with `ERROR` level. */
-    error(strings, ...data) {
-        this.config.transport.error(this.getLevelAndName(), strings, data);
+    error(val) {
+        this.config.transport.error(this.moduleName, val);
     }
 }
 
@@ -13753,7 +13717,7 @@ class LmdbStates {
             await Promise.all([valuesWrite, statesWrite]);
         }
         catch (e) {
-            logger.error `${e}`;
+            logger.error(`${e}`);
             return result_Result.error(StateUpdateError.Commit);
         }
         return result_Result.ok(result_OK);
@@ -13861,7 +13825,7 @@ class TypedPort {
                 this.dispatchPortMessage(msg);
             }
             catch (e) {
-                port_logger.error `[${this.constructor.name}] Failed to dispatch a message: ${e}: ${msg}`;
+                port_logger.error(`[${this.constructor.name}] Failed to dispatch a message: ${e}: ${JSON.stringify(msg)}`);
                 throw e;
             }
         });
@@ -13935,7 +13899,7 @@ class TypedPort {
             this.port.postMessage(msg, transferList);
         }
         catch (e) {
-            port_logger.error `[${this.constructor.name}] Failed to post a message: ${e}: ${msg}`;
+            port_logger.error(`[${this.constructor.name}] Failed to post a message: ${e}: ${JSON.stringify(msg)}`);
             throw e;
         }
     }
@@ -13966,7 +13930,7 @@ class TypedPort {
     cleanup(reason) {
         // resolve all pending requests with an error.
         const responseListeners = this.responseListeners.eventNames();
-        for (const ev of responseListeners) {
+        for (const ev in responseListeners) {
             this.responseListeners.emit(ev, new Error(`port is ${reason}`));
         }
     }
@@ -14015,7 +13979,7 @@ class channel_MessageChannelStateMachine {
                 this.dispatchSignal(name, data);
             }
             catch (e) {
-                channel_logger.error `[${this.constructor.name}] Unable to dispatch signal (${name}): ${e}. ${this.stateInfo(remoteState)}`;
+                channel_logger.error(`[${this.constructor.name}] Unable to dispatch signal (${name}): ${e}. ${this.stateInfo(remoteState)}`);
                 throw e;
             }
         });
@@ -14024,7 +13988,7 @@ class channel_MessageChannelStateMachine {
                 await this.dispatchRequest(name, data, msg);
             }
             catch (e) {
-                channel_logger.error `[${this.constructor.name}] Unable to dispatch request (${name}): ${e}. ${this.stateInfo(remoteState)}`;
+                channel_logger.error(`[${this.constructor.name}] Unable to dispatch request (${name}): ${e}. ${this.stateInfo(remoteState)}`);
                 throw e;
             }
         });
@@ -14110,7 +14074,7 @@ class channel_MessageChannelStateMachine {
             this.machine.transition(res.transitionTo.state, res.transitionTo.data);
         }
         if (didStateChangeInMeantime) {
-            channel_logger.warn `Ignoring obsolete response for an old request: "${name}"`;
+            channel_logger.warn(`Ignoring obsolete response for an old request: "${name}"`);
             return;
         }
         return this.port.respond(prevState.stateName, msg, res.response);
@@ -14126,7 +14090,7 @@ class channel_MessageChannelStateMachine {
         }
     }
     transitionTo() {
-        channel_logger.trace `[${this.machine.name}] transitioned to ${this.currentState()}`;
+        channel_logger.trace(`[${this.machine.name}] transitioned to ${this.currentState()}`);
         return this;
     }
     /**
@@ -14146,7 +14110,7 @@ class channel_MessageChannelStateMachine {
             await promise;
         }
         catch (e) {
-            channel_logger.error `${e}`;
+            channel_logger.error(JSON.stringify(e));
         }
         return new channel_MessageChannelStateMachine(machine, port);
     }
@@ -14349,7 +14313,7 @@ class State {
      * actions.
      */
     onActivation(data) {
-        state_logger.trace `[${this.constructor.name}] Changing state to: ${this}`;
+        state_logger.trace(`[${this.constructor.name}] Changing state to: ${this}`);
         this.data = data;
     }
     /**
@@ -16060,14 +16024,12 @@ class WriteablePage extends MemoryPage {
 
 
 
-
-
 var AccessType;
 (function (AccessType) {
     AccessType[AccessType["READ"] = 0] = "READ";
     AccessType[AccessType["WRITE"] = 1] = "WRITE";
 })(AccessType || (AccessType = {}));
-const memory_logger = Logger.new(import.meta.filename, "pvm:mem");
+// const logger = Logger.new(import.meta.filename, "pvm:mem");
 class Memory {
     sbrkIndex;
     virtualSbrkIndex;
@@ -16098,7 +16060,7 @@ class Memory {
         if (bytes.length === 0) {
             return result_Result.ok(result_OK);
         }
-        memory_logger.insane `MEM[${address}] <- ${bytes_BytesBlob.blobFrom(bytes)}`;
+        // logger.insane(`MEM[${address}] <- ${BytesBlob.blobFrom(bytes)}`);
         const pagesResult = this.getPages(address, bytes.length, AccessType.WRITE);
         if (pagesResult.isError) {
             return result_Result.error(pagesResult.error);
@@ -16165,7 +16127,7 @@ class Memory {
             currentPosition += bytesToRead;
             bytesLeft -= bytesToRead;
         }
-        memory_logger.insane `MEM[${startAddress}] => ${bytes_BytesBlob.blobFrom(result)}`;
+        // logger.insane(`MEM[${startAddress}] => ${BytesBlob.blobFrom(result)}`);
         return result_Result.ok(result_OK);
     }
     sbrk(length) {
@@ -18095,7 +18057,7 @@ class ProgramDecoder {
             return result_Result.ok(new ProgramDecoder(program));
         }
         catch (e) {
-            program_decoder_logger.error `Invalid program: ${e}`;
+            program_decoder_logger.error(`Invalid program: ${e}`);
             return result_Result.error(ProgramDecoderError.InvalidProgramError);
         }
     }
@@ -18261,7 +18223,7 @@ class Interpreter {
         const argsType = instructionArgumentTypeMap[currentInstruction] ?? ArgumentType.NO_ARGUMENTS;
         const argsResult = this.argsDecodingResults[argsType];
         this.argsDecoder.fillArgs(this.pc, argsResult);
-        interpreter_logger.insane `[PC: ${this.pc}] ${Instruction[currentInstruction]}`;
+        interpreter_logger.insane(`[PC: ${this.pc}] ${Instruction[currentInstruction]}`);
         if (!isValidInstruction) {
             this.instructionResult.status = pvm_interpreter_result_Result.PANIC;
         }
@@ -18333,7 +18295,7 @@ class Interpreter {
                     this.status = status_Status.HOST;
                     break;
             }
-            interpreter_logger.insane `[PC: ${this.pc}] Status: ${pvm_interpreter_result_Result[this.instructionResult.status]}`;
+            interpreter_logger.insane(`[PC: ${this.pc}] Status: ${pvm_interpreter_result_Result[this.instructionResult.status]}`);
             return this.status;
         }
         this.pc = this.instructionResult.nextPc;
@@ -18580,7 +18542,7 @@ class host_calls_manager_HostCallsManager {
             return `r${idx}=${value} (0x${value.toString(16)})`;
         })
             .join(", ");
-        host_calls_manager_logger.insane `[${currentServiceId}] ${context} ${name}${requested}.  Gas: ${gas}. Regs: ${registerValues}.`;
+        host_calls_manager_logger.insane(`[${currentServiceId}] ${context} ${name}${requested}.  Gas: ${gas}. Regs: ${registerValues}.`);
     }
 }
 class NoopMissing {
@@ -20963,7 +20925,7 @@ class AccumulateExternalities {
         /** https://graypaper.fluffylabs.dev/#/7e6ff6a/362802362d02?v=0.6.7 */
         const validatorsManager = this.updatedState.getPrivilegedServices().validatorsManager;
         if (validatorsManager !== this.currentServiceId) {
-            accumulate_externalities_logger.trace `Current service id (${this.currentServiceId}) is not a validators manager. (expected: ${validatorsManager}) and cannot update validators data. Ignoring`;
+            accumulate_externalities_logger.trace(`Current service id (${this.currentServiceId}) is not a validators manager. (expected: ${validatorsManager}) and cannot update validators data. Ignoring`);
             return result_Result.error(UnprivilegedError);
         }
         this.updatedState.stateUpdate.validatorsData = validatorsData;
@@ -20978,11 +20940,11 @@ class AccumulateExternalities {
         // NOTE `coreIndex` is already verified in the HC, so this is infallible.
         const currentAuthManager = this.updatedState.getPrivilegedServices().authManager[coreIndex];
         if (currentAuthManager !== this.currentServiceId) {
-            accumulate_externalities_logger.trace `Current service id (${this.currentServiceId}) is not an auth manager of core ${coreIndex} (expected: ${currentAuthManager}) and cannot update authorization queue. Ignoring`;
+            accumulate_externalities_logger.trace(`Current service id (${this.currentServiceId}) is not an auth manager of core ${coreIndex} (expected: ${currentAuthManager}) and cannot update authorization queue. Ignoring`);
             return result_Result.error(UpdatePrivilegesError.UnprivilegedService);
         }
         if (authManager === null && Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)) {
-            accumulate_externalities_logger.trace `The new auth manager is not a valid service id. Ignoring`;
+            accumulate_externalities_logger.trace("The new auth manager is not a valid service id. Ignoring");
             return result_Result.error(UpdatePrivilegesError.InvalidServiceId);
         }
         this.updatedState.stateUpdate.authorizationQueues.set(coreIndex, authQueue);
@@ -21863,7 +21825,7 @@ class Assign {
         const memoryReadResult = memory.loadInto(res, authorizationQueueStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace `ASSIGN() <- PANIC`;
+            logger_logger.trace("ASSIGN() <- PANIC");
             return PvmExecution.Panic;
         }
         if (maybeCoreIndex >= this.chainSpec.coresCount) {
@@ -21878,18 +21840,18 @@ class Assign {
         const result = this.partialState.updateAuthorizationQueue(coreIndex, fixedSizeAuthQueue, authManager);
         if (result.isOk) {
             regs.set(IN_OUT_REG, HostCallResult.OK);
-            logger_logger.trace `ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- OK`;
+            logger_logger.trace(`ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- OK`);
             return;
         }
         const e = result.error;
         if (e === UpdatePrivilegesError.UnprivilegedService) {
             regs.set(IN_OUT_REG, HostCallResult.HUH);
-            logger_logger.trace `ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- HUH`;
+            logger_logger.trace(`ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- HUH`);
             return;
         }
         if (e === UpdatePrivilegesError.InvalidServiceId) {
             regs.set(IN_OUT_REG, HostCallResult.WHO);
-            logger_logger.trace `ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- HUH`;
+            logger_logger.trace(`ASSIGN(${coreIndex}, ${fixedSizeAuthQueue}) <- HUH`);
             return;
         }
         debug_assertNever(e);
@@ -21955,7 +21917,7 @@ class Bless {
             decoder.resetTo(0);
             const memoryReadResult = memory.loadInto(result, memIndex);
             if (memoryReadResult.isError) {
-                logger_logger.trace `BLESS(${manager}, ${validator}) <- PANIC`;
+                logger_logger.trace(`BLESS(${manager}, ${validator}) <- PANIC`);
                 return PvmExecution.Panic;
             }
             const { serviceId, gas } = decoder.object(serviceIdAndGasCodec);
@@ -21968,24 +21930,24 @@ class Bless {
         const authorizersDecoder = decoder_Decoder.fromBlob(res);
         const memoryReadResult = memory.loadInto(res, authorization);
         if (memoryReadResult.isError) {
-            logger_logger.trace `BLESS(${manager}, ${validator}, ${autoAccumulateEntries}) <- PANIC`;
+            logger_logger.trace(`BLESS(${manager}, ${validator}, ${autoAccumulateEntries}) <- PANIC`);
             return PvmExecution.Panic;
         }
         const authorizers = tryAsPerCore(authorizersDecoder.sequenceFixLen(descriptors_codec.u32.asOpaque(), this.chainSpec.coresCount), this.chainSpec);
         const updateResult = this.partialState.updatePrivilegedServices(manager, authorizers, validator, autoAccumulateEntries);
         if (updateResult.isOk) {
-            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${validator}, ${autoAccumulateEntries}) <- OK`;
+            logger_logger.trace(`BLESS(${manager}, ${authorizers}, ${validator}, ${autoAccumulateEntries}) <- OK`);
             regs.set(bless_IN_OUT_REG, HostCallResult.OK);
             return;
         }
         const e = updateResult.error;
         if (e === UpdatePrivilegesError.UnprivilegedService) {
-            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${validator}, ${autoAccumulateEntries}) <- HUH`;
+            logger_logger.trace(`BLESS(${manager}, ${authorizers}, ${validator}, ${autoAccumulateEntries}) <- HUH`);
             regs.set(bless_IN_OUT_REG, HostCallResult.HUH);
             return;
         }
         if (e === UpdatePrivilegesError.InvalidServiceId) {
-            logger_logger.trace `BLESS(${manager}, ${authorizers}, ${validator}, ${autoAccumulateEntries}) <- WHO`;
+            logger_logger.trace(`BLESS(${manager}, ${authorizers}, ${validator}, ${autoAccumulateEntries}) <- WHO`);
             regs.set(bless_IN_OUT_REG, HostCallResult.WHO);
             return;
         }
@@ -22015,7 +21977,7 @@ class GasHostCall {
     }
     execute(gas, regs) {
         const gasValue = gas.get();
-        logger_logger.trace `GAS <- ${gasValue}`;
+        logger_logger.trace(`GAS <- ${gasValue}`);
         regs.set(7, numbers_tryAsU64(gasValue));
         return Promise.resolve(undefined);
     }
@@ -22047,7 +22009,7 @@ class Checkpoint {
     async execute(gas, regs) {
         await this.gasHostCall.execute(gas, regs);
         this.partialState.checkpoint();
-        logger_logger.trace `CHECKPOINT()`;
+        logger_logger.trace("CHECKPOINT()");
         return;
     }
 }
@@ -22086,18 +22048,18 @@ class Designate {
         const memoryReadResult = memory.loadInto(res, validatorsStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace `DESIGNATE() <- PANIC`;
+            logger_logger.trace("DESIGNATE() <- PANIC");
             return PvmExecution.Panic;
         }
         const decoder = decoder_Decoder.fromBlob(res);
         const validatorsData = decoder.sequenceFixLen(ValidatorData.Codec, this.chainSpec.validatorsCount);
         const result = this.partialState.updateValidatorsData(tryAsPerValidator(validatorsData, this.chainSpec));
         if (result.isError) {
-            logger_logger.trace `DESIGNATE([${validatorsData[0]}, ${validatorsData[1]}, ...]) <- HUH`;
+            logger_logger.trace(`DESIGNATE([${validatorsData[0]}, ${validatorsData[1]}, ...]) <- HUH`);
             regs.set(designate_IN_OUT_REG, HostCallResult.HUH);
         }
         else {
-            logger_logger.trace `DESIGNATE([${validatorsData[0]}, ${validatorsData[1]}, ...]) <- OK`;
+            logger_logger.trace(`DESIGNATE([${validatorsData[0]}, ${validatorsData[1]}, ...]) <- OK`);
             regs.set(designate_IN_OUT_REG, HostCallResult.OK);
         }
     }
@@ -22138,17 +22100,17 @@ class Eject {
         const previousCodeHash = bytes_Bytes.zero(hash_HASH_SIZE).asOpaque();
         const memoryReadResult = memory.loadInto(previousCodeHash.raw, preimageHashStart);
         if (memoryReadResult.isError) {
-            logger_logger.trace `EJECT(${serviceId}) <- PANIC`;
+            logger_logger.trace(`EJECT(${serviceId}) <- PANIC`);
             return PvmExecution.Panic;
         }
         // cannot eject self
         if (serviceId === this.currentServiceId) {
             regs.set(eject_IN_OUT_REG, HostCallResult.WHO);
-            logger_logger.trace `EJECT(${serviceId}, ${previousCodeHash}) <- WHO`;
+            logger_logger.trace(`EJECT(${serviceId}, ${previousCodeHash}) <- WHO`);
             return;
         }
         const result = this.partialState.eject(serviceId, previousCodeHash);
-        logger_logger.trace `EJECT(${serviceId}, ${previousCodeHash}) <- ${resultToString(result)}`;
+        logger_logger.trace(`EJECT(${serviceId}, ${previousCodeHash}) <- ${resultToString(result)}`);
         // All good!
         if (result.isOk) {
             regs.set(eject_IN_OUT_REG, HostCallResult.OK);
@@ -22200,11 +22162,11 @@ class Forget {
         const memoryReadResult = memory.loadInto(hash.raw, hashStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace `FORGET(${hash}, ${length}) <- PANIC`;
+            logger_logger.trace(`FORGET(${hash}, ${length}) <- PANIC`);
             return PvmExecution.Panic;
         }
         const result = this.partialState.forgetPreimage(hash.asOpaque(), length);
-        logger_logger.trace `FORGET(${hash}, ${length}) <- ${resultToString(result)}`;
+        logger_logger.trace(`FORGET(${hash}, ${length}) <- ${resultToString(result)}`);
         if (result.isOk) {
             regs.set(forget_IN_OUT_REG, HostCallResult.OK);
         }
@@ -22257,11 +22219,11 @@ class New {
         const memoryReadResult = memory.loadInto(codeHash.raw, codeHashStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace `NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}) <- PANIC`;
+            logger_logger.trace(`NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}) <- PANIC`);
             return PvmExecution.Panic;
         }
         const assignedId = this.partialState.newService(codeHash.asOpaque(), codeLength, gas, allowance, gratisStorage);
-        logger_logger.trace `NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}) <- ${resultToString(assignedId)}`;
+        logger_logger.trace(`NEW(${codeHash}, ${codeLength}, ${gas}, ${allowance}, ${gratisStorage}) <- ${resultToString(assignedId)}`);
         if (assignedId.isOk) {
             regs.set(new_IN_OUT_REG, numbers_tryAsU64(assignedId.ok));
             return;
@@ -22316,11 +22278,11 @@ class Provide {
         const preimage = bytes_BytesBlob.blobFrom(new Uint8Array(length));
         const memoryReadResult = memory.loadInto(preimage.raw, preimageStart);
         if (memoryReadResult.isError) {
-            logger_logger.trace `PROVIDE(${serviceId}, ${preimage.toStringTruncated()}) <- PANIC`;
+            logger_logger.trace(`PROVIDE(${serviceId}, ${preimage.toStringTruncated()}) <- PANIC`);
             return PvmExecution.Panic;
         }
         const result = this.partialState.providePreimage(serviceId, preimage);
-        logger_logger.trace `PROVIDE(${serviceId}, ${preimage.toStringTruncated()}) <- ${resultToString(result)}`;
+        logger_logger.trace(`PROVIDE(${serviceId}, ${preimage.toStringTruncated()}) <- ${resultToString(result)}`);
         if (result.isOk) {
             regs.set(provide_IN_OUT_REG, HostCallResult.OK);
             return;
@@ -22374,11 +22336,11 @@ class Query {
         const memoryReadResult = memory.loadInto(hash.raw, hashStart);
         // error while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace `QUERY(${hash}, ${length}) <- PANIC`;
+            logger_logger.trace(`QUERY(${hash}, ${length}) <- PANIC`);
             return PvmExecution.Panic;
         }
         const result = this.partialState.checkPreimageStatus(hash.asOpaque(), length);
-        logger_logger.trace `QUERY(${hash}, ${length}) <- ${result}`;
+        logger_logger.trace(`QUERY(${hash}, ${length}) <- ${result}`);
         const zero = numbers_tryAsU64(0n);
         if (result === null) {
             regs.set(IN_OUT_REG_1, HostCallResult.NONE);
@@ -22439,11 +22401,11 @@ class Solicit {
         const hash = bytes_Bytes.zero(hash_HASH_SIZE);
         const memoryReadResult = memory.loadInto(hash.raw, hashStart);
         if (memoryReadResult.isError) {
-            logger_logger.trace `SOLICIT(${hash}, ${length}) <- PANIC`;
+            logger_logger.trace(`SOLICIT(${hash}, ${length}) <- PANIC`);
             return PvmExecution.Panic;
         }
         const result = this.partialState.requestPreimage(hash.asOpaque(), length);
-        logger_logger.trace `SOLICIT(${hash}, ${length}) <- ${resultToString(result)}`;
+        logger_logger.trace(`SOLICIT(${hash}, ${length}) <- ${resultToString(result)}`);
         if (result.isOk) {
             regs.set(solicit_IN_OUT_REG, HostCallResult.OK);
             return;
@@ -22515,11 +22477,11 @@ class Transfer {
         const memoryReadResult = memory.loadInto(memo.raw, memoStart);
         // page fault while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace `TRANSFER(${destination}, ${amount}, ${onTransferGas}, ${memo}) <- PANIC`;
+            logger_logger.trace(`TRANSFER(${destination}, ${amount}, ${onTransferGas}, ${memo}) <- PANIC`);
             return PvmExecution.Panic;
         }
         const transferResult = this.partialState.transfer(destination, amount, onTransferGas, memo);
-        logger_logger.trace `TRANSFER(${destination}, ${amount}, ${onTransferGas}, ${memo}) <- ${resultToString(transferResult)}`;
+        logger_logger.trace(`TRANSFER(${destination}, ${amount}, ${onTransferGas}, ${memo}) <- ${resultToString(transferResult)}`);
         // All good!
         if (transferResult.isOk) {
             regs.set(transfer_IN_OUT_REG, HostCallResult.OK);
@@ -22578,11 +22540,11 @@ class Upgrade {
         const codeHash = bytes_Bytes.zero(hash_HASH_SIZE);
         const memoryReadResult = memory.loadInto(codeHash.raw, codeHashStart);
         if (memoryReadResult.isError) {
-            logger_logger.trace `UPGRADE(${codeHash}, ${gas}, ${allowance}) <- PANIC`;
+            logger_logger.trace(`UPGRADE(${codeHash}, ${gas}, ${allowance}) <- PANIC`);
             return PvmExecution.Panic;
         }
         this.partialState.upgradeService(codeHash.asOpaque(), gas, allowance);
-        logger_logger.trace `UPGRADE(${codeHash}, ${gas}, ${allowance})`;
+        logger_logger.trace(`UPGRADE(${codeHash}, ${gas}, ${allowance})`);
         regs.set(upgrade_IN_OUT_REG, HostCallResult.OK);
     }
 }
@@ -22616,11 +22578,11 @@ class Yield {
         const hash = bytes_Bytes.zero(hash_HASH_SIZE);
         const memoryReadResult = memory.loadInto(hash.raw, hashStart);
         if (memoryReadResult.isError) {
-            logger_logger.trace `YIELD() <- PANIC`;
+            logger_logger.trace("YIELD() <- PANIC");
             return PvmExecution.Panic;
         }
         this.partialState.yield(hash);
-        logger_logger.trace `YIELD(${hash})`;
+        logger_logger.trace(`YIELD(${hash})`);
         regs.set(yield_IN_OUT_REG, HostCallResult.OK);
     }
 }
@@ -22662,10 +22624,10 @@ class Fetch {
         const chunk = value === null ? new Uint8Array() : value.raw.subarray(Number(offset), Number(offset + length));
         const storeResult = memory.storeFrom(output, chunk);
         if (storeResult.isError) {
-            logger_logger.trace `FETCH(${kind}) <- PANIC`;
+            logger_logger.trace(`FETCH(${kind}) <- PANIC`);
             return PvmExecution.Panic;
         }
-        logger_logger.trace `FETCH(${kind}) <- ${value?.toStringTruncated()}`;
+        logger_logger.trace(`FETCH(${kind}) <- ${value?.toStringTruncated()}`);
         // write result
         regs.set(fetch_IN_OUT_REG, value === null ? HostCallResult.NONE : valueLength);
     }
@@ -22824,10 +22786,10 @@ class Info {
         const chunk = encodedInfo.raw.subarray(Number(offset), Number(offset + length));
         const writeResult = memory.storeFrom(outputStart, chunk);
         if (writeResult.isError) {
-            logger_logger.trace `INFO(${serviceId}) <- PANIC`;
+            logger_logger.trace(`INFO(${serviceId}) <- PANIC`);
             return PvmExecution.Panic;
         }
-        logger_logger.trace `INFO(${serviceId}) <- ${bytes_BytesBlob.blobFrom(chunk)}`;
+        logger_logger.trace(`INFO(${serviceId}) <- ${bytes_BytesBlob.blobFrom(chunk)}`);
         if (accountInfo === null) {
             regs.set(info_IN_OUT_REG, HostCallResult.NONE);
             return;
@@ -22888,7 +22850,7 @@ class LogHostCall {
             memory.loadInto(target, targetStart);
         }
         memory.loadInto(message, msgStart);
-        logger_logger.trace `SERVICE [${this.currentServiceId}] [${lvl}] ${decoder.decode(target)} ${decoder.decode(message)}`;
+        logger_logger.trace(`SERVICE [${this.currentServiceId}] [${lvl}] ${decoder.decode(target)} ${decoder.decode(message)}`);
         return Promise.resolve(undefined);
     }
 }
@@ -22928,12 +22890,12 @@ class Lookup {
         const preImageHash = bytes_Bytes.zero(hash_HASH_SIZE);
         const memoryReadResult = memory.loadInto(preImageHash.raw, hashAddress);
         if (memoryReadResult.isError) {
-            logger_logger.trace `LOOKUP(${serviceId}, ${preImageHash}) <- PANIC`;
+            logger_logger.trace(`LOOKUP(${serviceId}, ${preImageHash}) <- PANIC`);
             return PvmExecution.Panic;
         }
         // v
         const preImage = this.account.lookup(serviceId, preImageHash);
-        logger_logger.trace `LOOKUP(${serviceId}, ${preImageHash}) <- ${preImage?.toStringTruncated()}...`;
+        logger_logger.trace(`LOOKUP(${serviceId}, ${preImageHash}) <- ${preImage?.toStringTruncated()}...`);
         const preImageLength = preImage === null ? numbers_tryAsU64(0) : numbers_tryAsU64(preImage.raw.length);
         const preimageBlobOffset = regs.get(10);
         const lengthToWrite = regs.get(11);
@@ -22995,7 +22957,7 @@ class Read {
         const rawKey = bytes_BytesBlob.blobFrom(new Uint8Array(storageKeyLengthClamped));
         const memoryReadResult = memory.loadInto(rawKey.raw, storageKeyStartAddress);
         if (memoryReadResult.isError) {
-            logger_logger.trace `READ(${serviceId}, ${rawKey}) <- PANIC`;
+            logger_logger.trace(`READ(${serviceId}, ${rawKey}) <- PANIC`);
             return PvmExecution.Panic;
         }
         // v
@@ -23013,15 +22975,15 @@ class Read {
         const chunk = value === null ? new Uint8Array(0) : value.raw.subarray(Number(offset), Number(offset + blobLength));
         const memoryWriteResult = memory.storeFrom(destinationAddress, chunk);
         if (memoryWriteResult.isError) {
-            logger_logger.trace `READ(${serviceId}, ${rawKey}) <- PANIC`;
+            logger_logger.trace(`READ(${serviceId}, ${rawKey}) <- PANIC`);
             return PvmExecution.Panic;
         }
         if (value === null) {
-            logger_logger.trace `READ(${serviceId}, ${rawKey}) <- NONE`;
+            logger_logger.trace(`READ(${serviceId}, ${rawKey}) <- NONE`);
             regs.set(read_IN_OUT_REG, HostCallResult.NONE);
             return;
         }
-        logger_logger.trace `READ(${serviceId}, ${rawKey}) <- ${bytes_BytesBlob.blobFrom(chunk).toStringTruncated()}`;
+        logger_logger.trace(`READ(${serviceId}, ${rawKey}) <- ${bytes_BytesBlob.blobFrom(chunk).toStringTruncated()}`);
         regs.set(read_IN_OUT_REG, valueLength);
     }
 }
@@ -23064,7 +23026,7 @@ class Write {
         const rawStorageKey = new Uint8Array(storageKeyLengthClamped);
         const keyLoadingResult = memory.loadInto(rawStorageKey, storageKeyStartAddress);
         if (keyLoadingResult.isError) {
-            logger_logger.trace `WRITE() <- PANIC`;
+            logger_logger.trace("WRITE() <- PANIC");
             return PvmExecution.Panic;
         }
         // k
@@ -23074,14 +23036,14 @@ class Write {
         const valueLoadingResult = memory.loadInto(value, valueStart);
         // Note [MaSo] this is ok to return bcs if valueLength is 0, then this panic won't happen
         if (valueLoadingResult.isError) {
-            logger_logger.trace `WRITE(${storageKey}) <- PANIC`;
+            logger_logger.trace(`WRITE(${storageKey})}) <- PANIC`);
             return PvmExecution.Panic;
         }
         /** https://graypaper.fluffylabs.dev/#/9a08063/33af0133b201?v=0.6.6 */
         const maybeValue = valueLength === 0n ? null : bytes_BytesBlob.blobFrom(value);
         // a
         const result = this.account.write(storageKey, maybeValue);
-        logger_logger.trace `WRITE(${storageKey}, ${maybeValue?.toStringTruncated()}) <- ${resultToString(result)}`;
+        logger_logger.trace(`WRITE(${storageKey}, ${maybeValue?.toStringTruncated()}) <- ${resultToString(result)}`);
         if (result.isError) {
             regs.set(write_IN_OUT_REG, HostCallResult.FULL);
             return;
@@ -23273,18 +23235,18 @@ class Accumulate {
     async pvmAccumulateInvocation(slot, serviceId, operands, gas, entropy, inputStateUpdate) {
         const service = this.state.getService(serviceId);
         if (service === null) {
-            accumulate_logger.log `Service with id ${serviceId} not found.`;
+            accumulate_logger.log(`Service with id ${serviceId} not found.`);
             return result_Result.error(PvmInvocationError.NoService);
         }
         const codeHash = service.getInfo().codeHash;
         // TODO [ToDr] Should we check that the preimage is still available?
         const code = service.getPreimage(codeHash.asOpaque());
         if (code === null) {
-            accumulate_logger.log `Code with hash ${codeHash} not found for service ${serviceId}.`;
+            accumulate_logger.log(`Code with hash ${codeHash} not found for service ${serviceId}.`);
             return result_Result.error(PvmInvocationError.NoPreimage);
         }
         if (code.length > W_C) {
-            accumulate_logger.log `Code with hash ${codeHash} is too long for service ${serviceId}.`;
+            accumulate_logger.log(`Code with hash ${codeHash} is too long for service ${serviceId}.`);
             return result_Result.error(PvmInvocationError.PreimageTooLong);
         }
         const nextServiceId = generateNextServiceId({ serviceId, entropy, timeslot: slot }, this.chainSpec);
@@ -23306,10 +23268,10 @@ class Accumulate {
         if (result.hasStatus()) {
             const status = result.status;
             if (status === status_Status.OOG || status === status_Status.PANIC) {
-                accumulate_logger.trace `[${serviceId}] accumulate finished with ${status_Status[status]} reverting to checkpoint.`;
+                accumulate_logger.trace(`[${serviceId}] accumulate finished with ${status_Status[status]} reverting to checkpoint.`);
                 return result_Result.ok({ stateUpdate: checkpoint, consumedGas: common_tryAsServiceGas(result.consumedGas) });
             }
-            accumulate_logger.trace `[${serviceId}] accumulate finished with ${status_Status[status]}`;
+            accumulate_logger.trace(`[${serviceId}] accumulate finished with ${status_Status[status]}`);
         }
         /**
          * PVM invocation returned a hash so we override whatever `yield` host call
@@ -23334,14 +23296,14 @@ class Accumulate {
      * https://graypaper.fluffylabs.dev/#/7e6ff6a/18d70118d701?v=0.6.7
      */
     async accumulateSingleService(serviceId, operands, gasCost, slot, entropy, inputStateUpdate) {
-        accumulate_logger.log `Accumulating service ${serviceId}, items: ${operands.length} at slot: ${slot}.`;
+        accumulate_logger.log(`Accumulating service ${serviceId}, items: ${operands.length} at slot: ${slot}.`);
         const result = await this.pvmAccumulateInvocation(slot, serviceId, operands, gasCost, entropy, inputStateUpdate);
         if (result.isError) {
             // https://graypaper.fluffylabs.dev/#/7e6ff6a/2fb6012fb601?v=0.6.7
-            accumulate_logger.log `Accumulation failed for ${serviceId}.`;
+            accumulate_logger.log(`Accumulation failed for ${serviceId}.`);
             return { stateUpdate: null, consumedGas: 0n };
         }
-        accumulate_logger.log `Accumulation successful for ${serviceId}. Consumed: ${result.ok.consumedGas}`;
+        accumulate_logger.log(`Accumulation successful for ${serviceId}. Consumed: ${result.ok.consumedGas}`);
         return result.ok;
     }
     /**
@@ -23390,7 +23352,6 @@ class Accumulate {
         const serviceIds = accumulateData.getServiceIds();
         let gasCost = common_tryAsServiceGas(0);
         let currentState = inputStateUpdate;
-        const currentManager = (inputStateUpdate.privilegedServices ?? this.state.privilegedServices).manager;
         for (const serviceId of serviceIds) {
             const checkpoint = AccumulationStateUpdate.copyFrom(currentState);
             const { consumedGas, stateUpdate } = await this.accumulateSingleService(serviceId, accumulateData.getOperands(serviceId), accumulateData.getGasCost(serviceId), slot, entropy, currentState);
@@ -23400,21 +23361,6 @@ class Accumulate {
             serviceStatistics.gasUsed = common_tryAsServiceGas(serviceStatistics.gasUsed + consumedGas);
             statistics.set(serviceId, serviceStatistics);
             currentState = stateUpdate === null ? checkpoint : stateUpdate;
-            if (Compatibility.is(GpVersion.V0_7_0) && serviceId === currentManager) {
-                const newV = currentState.privilegedServices?.validatorsManager;
-                if (currentState.privilegedServices !== null && newV !== undefined && serviceIds.includes(newV)) {
-                    accumulate_logger.info `Entering completely incorrect code that probably reverts validatorsManager change. This is valid in 0.7.0 only and incorrect in 0.7.1+`;
-                    // Since serviceIds already contains newV, this service gets accumulated twice.
-                    // To avoid double-counting, we skip stats and gas cost tracking here.
-                    // We need this accumulation to get the correct `validatorsManager`
-                    const { stateUpdate } = await this.accumulateSingleService(newV, accumulateData.getOperands(newV), accumulateData.getGasCost(newV), slot, entropy, checkpoint);
-                    const correctV = stateUpdate?.privilegedServices?.validatorsManager ?? this.state.privilegedServices.validatorsManager;
-                    currentState.privilegedServices = PrivilegedServices.create({
-                        ...currentState.privilegedServices,
-                        validatorsManager: correctV,
-                    });
-                }
-            }
         }
         return {
             state: currentState,
@@ -23559,14 +23505,11 @@ class DeferredTransfers {
     async transition({ pendingTransfers, timeslot, servicesUpdate: inputServicesUpdate, entropy, }) {
         // https://graypaper.fluffylabs.dev/#/7e6ff6a/187a03187a03?v=0.6.7
         const transferStatistics = new Map();
-        const services = uniquePreserveOrder(pendingTransfers.map((x) => x.destination));
+        const services = uniquePreserveOrder(pendingTransfers.flatMap((x) => [x.source, x.destination]));
         let currentStateUpdate = AccumulationStateUpdate.new(inputServicesUpdate);
         for (const serviceId of services) {
             const partiallyUpdatedState = new PartiallyUpdatedState(this.state, currentStateUpdate);
-            // https://graypaper.fluffylabs.dev/#/38c4e62/18750318ae03?v=0.7.0
-            const transfers = pendingTransfers
-                .filter((pendingTransfer) => pendingTransfer.destination === serviceId)
-                .toSorted((a, b) => a.source - b.source);
+            const transfers = pendingTransfers.filter((pendingTransfer) => pendingTransfer.destination === serviceId);
             const info = partiallyUpdatedState.getServiceInfo(serviceId);
             if (info === null) {
                 return result_Result.error(DeferredTransfersErrorCode.ServiceInfoNotExist);
@@ -23586,13 +23529,13 @@ class DeferredTransfers {
             const isCodeCorrect = code !== null && code.length <= W_C;
             if (!hasTransfers || !isCodeCorrect) {
                 if (code === null) {
-                    deferred_transfers_logger.trace `Skipping ON_TRANSFER execution for service ${serviceId} because code is null`;
+                    deferred_transfers_logger.trace(`Skipping ON_TRANSFER execution for service ${serviceId} because code is null`);
                 }
                 else if (!hasTransfers) {
-                    deferred_transfers_logger.trace `Skipping ON_TRANSFER execution for service ${serviceId} because there are no transfers`;
+                    deferred_transfers_logger.trace(`Skipping ON_TRANSFER execution for service ${serviceId} because there are no transfers`);
                 }
                 else {
-                    deferred_transfers_logger.trace `Skipping ON_TRANSFER execution for service ${serviceId} because code is too long`;
+                    deferred_transfers_logger.trace(`Skipping ON_TRANSFER execution for service ${serviceId} because code is too long`);
                 }
             }
             else {
@@ -24220,7 +24163,7 @@ function verifyRefineContexts(minLookupSlot, contexts, recentBlocksPartialUpdate
             headerChain.isAncestor(context.lookupAnchorSlot, context.lookupAnchor, context.anchor);
         if (!isInChain) {
             if (process.env.SKIP_LOOKUP_ANCHOR_CHECK !== undefined) {
-                verify_contextual_logger.warn `Lookup anchor check for ${context.lookupAnchor} would fail, but override is active.`;
+                verify_contextual_logger.warn(`Lookup anchor check for ${context.lookupAnchor} would fail, but override is active.`);
             }
             else {
                 return result_Result.error(ReportsError.SegmentRootLookupInvalid, `Lookup anchor is not found in chain. Hash: ${context.lookupAnchor} (slot: ${context.lookupAnchorSlot})`);
@@ -25107,7 +25050,7 @@ class OnChain {
             reports: availableReports,
             entropy: entropy[0],
         });
-        chain_stf_logger.log `${timerAccumulate()}`;
+        chain_stf_logger.log(timerAccumulate());
         if (accumulateResult.isError) {
             return stfError(StfErrorKind.Accumulate, accumulateResult);
         }
@@ -25238,7 +25181,7 @@ class Importer {
         this.stf = new OnChain(spec, state, blocks, hasher);
         this.state = state;
         this.currentHash = currentBestHeaderHash;
-        logger.info `😎 Best time slot: ${state.timeslot} (header hash: ${currentBestHeaderHash})`;
+        logger.info(`😎 Best time slot: ${state.timeslot} (header hash: ${currentBestHeaderHash})`);
     }
     async importBlock(block, omitSealVerification) {
         const timer = measure("importBlock");
@@ -25246,20 +25189,20 @@ class Importer {
         const maybeBestHeader = await this.importBlockInternal(block, omitSealVerification);
         if (maybeBestHeader.isOk) {
             const bestHeader = maybeBestHeader.ok;
-            this.logger.info `🧊 Best block: #${timeSlot} (${bestHeader.hash})`;
-            this.logger.log `${timer()}`;
+            this.logger.info(`🧊 Best block: #${timeSlot} (${bestHeader.hash})`);
+            this.logger.log(timer());
             return maybeBestHeader;
         }
-        this.logger.log `❌ Rejected block #${timeSlot}: ${resultToString(maybeBestHeader)}`;
-        this.logger.log `${timer()}`;
+        this.logger.log(`❌ Rejected block #${timeSlot}: ${resultToString(maybeBestHeader)}`);
+        this.logger.log(timer());
         return maybeBestHeader;
     }
     async importBlockInternal(block, omitSealVerification = false) {
         const logger = this.logger;
-        logger.log `🧱 Attempting to import a new block`;
+        logger.log("🧱 Attempting to import a new block");
         const timerVerify = measure("import:verify");
         const hash = await this.verifier.verifyBlock(block);
-        logger.log `${timerVerify()}`;
+        logger.log(timerVerify());
         if (hash.isError) {
             return importerError(ImporterErrorKind.Verifier, hash);
         }
@@ -25279,10 +25222,10 @@ class Importer {
         }
         const timeSlot = block.header.view().timeSlotIndex.materialize();
         const headerHash = hash.ok;
-        logger.log `🧱 Verified block: Got hash ${headerHash} for block at slot ${timeSlot}.`;
+        logger.log(`🧱 Verified block: Got hash ${headerHash} for block at slot ${timeSlot}.`);
         const timerStf = measure("import:stf");
         const res = await this.stf.transition(block, headerHash, omitSealVerification);
-        logger.log `${timerStf()}`;
+        logger.log(timerStf());
         if (res.isError) {
             return importerError(ImporterErrorKind.Stf, res);
         }
@@ -25291,7 +25234,7 @@ class Importer {
         const timerState = measure("import:state");
         const updateResult = await this.states.updateAndSetState(headerHash, this.state, update);
         if (updateResult.isError) {
-            logger.error `🧱 Unable to update state: ${resultToString(updateResult)}`;
+            logger.error(`🧱 Unable to update state: ${resultToString(updateResult)}`);
             return importerError(ImporterErrorKind.Update, updateResult);
         }
         const newState = this.states.getState(headerHash);
@@ -25302,17 +25245,17 @@ class Importer {
         // the state of a parent block to support forks and create a fresh STF.
         this.state.updateBackend(newState.backend);
         this.currentHash = headerHash;
-        logger.log `${timerState()}`;
+        logger.log(timerState());
         // insert new state and the block to DB.
         const timerDb = measure("import:db");
         const writeBlocks = this.blocks.insertBlock(new WithHash(headerHash, block));
         // Computation of the state root may happen asynchronously,
         // but we still need to wait for it before next block can be imported
         const stateRoot = await this.states.getStateRoot(newState);
-        logger.log `🧱 Storing post-state-root for ${headerHash}: ${stateRoot}.`;
+        logger.log(`🧱 Storing post-state-root for ${headerHash}: ${stateRoot}.`);
         const writeStateRoot = this.blocks.setPostStateRoot(headerHash, stateRoot);
         await Promise.all([writeBlocks, writeStateRoot]);
-        logger.log `${timerDb()}`;
+        logger.log(timerDb());
         // finally update the best block
         await this.blocks.setBestHeaderHash(headerHash);
         return result_Result.ok(new WithHash(headerHash, block.header.view()));
@@ -25414,7 +25357,7 @@ async function spawnWorkerGeneric(bootstrapPath, logger, mainReadyName, mainRead
     const worker = new Worker(bootstrapPath);
     const machine = stateMachineMain(`main->${mainReadyName}`, mainReadyName, mainReadyState);
     const channel = await MessageChannelStateMachine.createAndTransferChannel(machine, worker);
-    logger.trace `[${machine.name}] Worker spawned ${channel.currentState()}`;
+    logger.trace(`[${machine.name}] Worker spawned ${channel.currentState()}`);
     return channel;
 }
 
@@ -25527,7 +25470,7 @@ class MainReady extends State {
         if (res instanceof Uint8Array) {
             return bytes_Bytes.fromBlob(res, hash_HASH_SIZE).asOpaque();
         }
-        state_machine_logger.error `Invalid response for getBestStateRootHash. Expected Uint8Array, got: ${res}`;
+        state_machine_logger.error(`Invalid response for getBestStateRootHash. Expected Uint8Array, got: ${res}`);
         return bytes_Bytes.zero(hash_HASH_SIZE).asOpaque();
     }
     finish(channel) {
@@ -25575,7 +25518,7 @@ class ImporterReady extends State {
     }
     async getStateEntries(hash) {
         if (this.importer === null) {
-            state_machine_logger.error `${this.constructor.name} importer not initialized yet!`;
+            state_machine_logger.error(`${this.constructor.name} importer not initialized yet!`);
             await new Promise((resolve) => {
                 this.onImporter.once(resolve);
             });
@@ -25589,7 +25532,7 @@ class ImporterReady extends State {
                 response: encoded.raw,
             };
         }
-        state_machine_logger.error `${this.constructor.name} got invalid request type: ${JSON.stringify(hash)}.`;
+        state_machine_logger.error(`${this.constructor.name} got invalid request type: ${JSON.stringify(hash)}.`);
         return {
             response: null,
         };
@@ -25609,7 +25552,7 @@ class ImporterReady extends State {
     }
     async importBlock(block) {
         if (this.importer === null) {
-            state_machine_logger.error `${this.constructor.name} importer not initialized yet!`;
+            state_machine_logger.error(`${this.constructor.name} importer not initialized yet!`);
             await new Promise((resolve) => {
                 this.onImporter.once(resolve);
             });
@@ -25629,8 +25572,8 @@ class ImporterReady extends State {
                 }
             }
             catch (e) {
-                state_machine_logger.error `Failed to import block: ${e}`;
-                state_machine_logger.error `${e instanceof Error ? e.stack : ""}`;
+                state_machine_logger.error(`Failed to import block: ${e}`);
+                state_machine_logger.error(`${e instanceof Error ? e.stack : ""}`);
                 response = result_Result.error(`${e}`);
             }
             const encoded = encoder_Encoder.encodeObject(importBlockResultCodec, response);
@@ -25638,7 +25581,7 @@ class ImporterReady extends State {
                 response: encoded.raw,
             };
         }
-        state_machine_logger.error `${this.constructor.name} got invalid request type: ${JSON.stringify(block)}.`;
+        state_machine_logger.error(`${this.constructor.name} got invalid request type: ${JSON.stringify(block)}.`);
         return {
             response: null,
         };
@@ -25650,7 +25593,7 @@ class ImporterReady extends State {
             this.onBlock.emit(blockView);
         }
         else {
-            state_machine_logger.error `${this.constructor.name} got invalid signal type: ${JSON.stringify(block)}.`;
+            state_machine_logger.error(`${this.constructor.name} got invalid signal type: ${JSON.stringify(block)}.`);
         }
     }
     async endWork() {
@@ -25677,7 +25620,7 @@ if (!external_node_worker_threads_namespaceObject.isMainThread) {
     Logger.configureAll(process.env.JAM_LOG ?? "", Level.LOG);
     const machine = importerStateMachine();
     const channel = channel_MessageChannelStateMachine.receiveChannel(machine, external_node_worker_threads_namespaceObject.parentPort);
-    channel.then((channel) => main(channel)).catch((e) => importer_logger.error `${e}`);
+    channel.then((channel) => main(channel)).catch((e) => importer_logger.error(e));
 }
 const keccakHasher = KeccakHasher.create();
 async function createImporter(config) {
@@ -25699,7 +25642,7 @@ async function createImporter(config) {
  */
 async function main(channel) {
     const wasmPromise = initAll();
-    importer_logger.info `📥 Importer starting ${channel.currentState()}`;
+    importer_logger.info(`📥 Importer starting ${channel.currentState()}`);
     // Await the configuration object
     const ready = await channel.waitForState("ready(importer)");
     let closeDb = async () => { };
@@ -25711,7 +25654,7 @@ async function main(channel) {
         };
         // TODO [ToDr] this is shit, since we have circular dependency.
         worker.setImporter(importer);
-        importer_logger.info `📥 Importer waiting for blocks.`;
+        importer_logger.info("📥 Importer waiting for blocks.");
         worker.onBlock.on(async (block) => {
             const res = await importer.importBlock(block, config.omitSealVerification);
             if (res.isOk) {
@@ -25720,7 +25663,7 @@ async function main(channel) {
         });
         await wasmPromise;
     });
-    importer_logger.info `📥 Importer finished. Closing channel.`;
+    importer_logger.info("📥 Importer finished. Closing channel.");
     // close the database
     await closeDb();
     // Close the comms to gracefuly close the app.