@typeberry/jam 0.1.1-e48de40 → 0.1.1

package/block-generator/index.js

@@ -3766,34 +3766,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
@@ -4137,7 +4109,6 @@ function isResult(x) {
 
 
 
-
 ;// CONCATENATED MODULE: ./packages/core/bytes/bitvec.ts
 
 /**
@@ -12975,23 +12946,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.
@@ -13022,91 +12976,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(moduleName, val) {
+        this.push(Level.ERROR, moduleName, val);
     }
-    error(levelAndName, strings, data) {
-        print(Level.ERROR, levelAndName, strings, data);
+    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);
     }
 }
 
@@ -13143,6 +13115,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.
      *
@@ -13173,46 +13150,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);
     }
 }
 
@@ -13327,7 +13291,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);
@@ -13435,7 +13399,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;
             }
         });
@@ -13509,7 +13473,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;
         }
     }
@@ -13540,7 +13504,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}`));
         }
     }
@@ -13589,7 +13553,7 @@ class 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;
             }
         });
@@ -13598,7 +13562,7 @@ class 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;
             }
         });
@@ -13684,7 +13648,7 @@ class 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);
@@ -13700,7 +13664,7 @@ class MessageChannelStateMachine {
         }
     }
     transitionTo() {
-        channel_logger.trace `[${this.machine.name}] transitioned to ${this.currentState()}`;
+        channel_logger.trace(`[${this.machine.name}] transitioned to ${this.currentState()}`);
         return this;
     }
     /**
@@ -13720,7 +13684,7 @@ class MessageChannelStateMachine {
             await promise;
         }
         catch (e) {
-            channel_logger.error `${e}`;
+            channel_logger.error(JSON.stringify(e));
         }
         return new MessageChannelStateMachine(machine, port);
     }
@@ -13923,7 +13887,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;
     }
     /**
@@ -14021,7 +13985,7 @@ async function spawnWorkerGeneric(bootstrapPath, logger, mainReadyName, mainRead
     const worker = new external_node_worker_threads_namespaceObject.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;
 }
 
@@ -15599,14 +15563,12 @@ class writeable_page_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_Memory {
     sbrkIndex;
     virtualSbrkIndex;
@@ -15637,7 +15599,7 @@ class memory_Memory {
         if (bytes.length === 0) {
             return Result.ok(OK);
         }
-        memory_logger.insane `MEM[${address}] <- ${BytesBlob.blobFrom(bytes)}`;
+        // logger.insane(`MEM[${address}] <- ${BytesBlob.blobFrom(bytes)}`);
         const pagesResult = this.getPages(address, bytes.length, AccessType.WRITE);
         if (pagesResult.isError) {
             return Result.error(pagesResult.error);
@@ -15704,7 +15666,7 @@ class memory_Memory {
             currentPosition += bytesToRead;
             bytesLeft -= bytesToRead;
         }
-        memory_logger.insane `MEM[${startAddress}] => ${BytesBlob.blobFrom(result)}`;
+        // logger.insane(`MEM[${startAddress}] => ${BytesBlob.blobFrom(result)}`);
         return Result.ok(OK);
     }
     sbrk(length) {
@@ -17441,7 +17403,7 @@ class program_decoder_ProgramDecoder {
             return Result.ok(new program_decoder_ProgramDecoder(program));
         }
         catch (e) {
-            program_decoder_logger.error `Invalid program: ${e}`;
+            program_decoder_logger.error(`Invalid program: ${e}`);
             return Result.error(ProgramDecoderError.InvalidProgramError);
         }
     }
@@ -17607,7 +17569,7 @@ class interpreter_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 = Result.PANIC;
         }
@@ -17679,7 +17641,7 @@ class interpreter_Interpreter {
                     this.status = Status.HOST;
                     break;
             }
-            interpreter_logger.insane `[PC: ${this.pc}] Status: ${Result[this.instructionResult.status]}`;
+            interpreter_logger.insane(`[PC: ${this.pc}] Status: ${Result[this.instructionResult.status]}`);
             return this.status;
         }
         this.pc = this.instructionResult.nextPc;
@@ -17926,7 +17888,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 {
@@ -18513,7 +18475,7 @@ class MainReady extends State {
             this.onBlock.emit(block);
         }
         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)}.`);
         }
     }
     finish(channel) {
@@ -18568,12 +18530,12 @@ if (!external_node_worker_threads_namespaceObject.isMainThread) {
     channel
         .then((channel) => main(channel))
         .catch((e) => {
-        block_generator_logger.error `${e}`;
+        block_generator_logger.error(e);
         if (e.stack !== undefined) {
-            block_generator_logger.error `${e.stack}`;
+            block_generator_logger.error(e.stack);
         }
         if (e.cause !== undefined) {
-            block_generator_logger.error `${e.cause}`;
+            block_generator_logger.error(e.cause);
         }
     });
 }
@@ -18581,7 +18543,7 @@ if (!external_node_worker_threads_namespaceObject.isMainThread) {
  * The `BlockGenerator` should periodically create new blocks and send them as signals to the main thread.
  */
 async function main(channel) {
-    block_generator_logger.info `🎁 Block Generator running ${channel.currentState()}`;
+    block_generator_logger.info(`🎁 Block Generator running ${channel.currentState()}`);
     // Await the configuration object
     const ready = await channel.waitForState("ready(generator)");
     const config = ready.currentState().getConfig();
@@ -18596,11 +18558,11 @@ async function main(channel) {
             await (0,promises_namespaceObject.setTimeout)(config.chainSpec.slotDuration * 1000);
             counter += 1;
             const newBlock = await generator.nextEncodedBlock();
-            block_generator_logger.trace `Sending block ${counter}`;
+            block_generator_logger.trace(`Sending block ${counter}`);
             worker.sendBlock(port, newBlock);
         }
     });
-    block_generator_logger.info `Block Generator finished. Closing channel.`;
+    block_generator_logger.info("Block Generator finished. Closing channel.");
     // Close the comms to gracefully close the app.
     finished.currentState().close(channel);
 }