@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

package/packages/core/logger/logger.d.ts

@@ -0,0 +1,54 @@
+import { Level, type Options } from "./options.js";
+import type { TransportBuilder } from "./transport.js";
+/**
+ * A logger instance.
+ */
+export declare class Logger {
+    private readonly moduleName;
+    private readonly config;
+    /**
+     * Create a new logger instance given filename and an optional module name.
+     *
+     * If the module name is not given, `fileName` becomes the module name.
+     * The module name can be composed from multiple parts separated with `/`.
+     *
+     * The logger will use a global configuration which can be changed using
+     * [`configureLogger`] function.
+     */
+    static new(fileName?: string, moduleName?: string): Logger;
+    /**
+     * Global configuration of all loggers.
+     *
+     * One can specify a default logging level (only logs with level >= default will be printed).
+     * It's also possible to configure per-module logging level that takes precedence
+     * over the default one.
+     *
+     * Changing the options affects all previously created loggers.
+     */
+    static configureAllFromOptions(options: Options, createTransport?: TransportBuilder): void;
+    /**
+     * Global configuration of all loggers.
+     *
+     * Parse configuration options from an input string typically obtained
+     * from environment variable `JAM_LOG`.
+     */
+    static configureAll(input: string, defaultLevel: Level, workingDir?: string): void;
+    private cachedLevelAndName?;
+    private constructor();
+    /** Return currently configured level for given module. */
+    getLevel(): Level;
+    private getLevelAndName;
+    /** Log a message with `INSANE` level. */
+    insane(strings: TemplateStringsArray, ...data: unknown[]): void;
+    /** Log a message with `TRACE` level. */
+    trace(strings: TemplateStringsArray, ...data: unknown[]): void;
+    /** Log a message with `DEBUG`/`LOG` level. */
+    log(strings: TemplateStringsArray, ...data: unknown[]): void;
+    /** Log a message with `INFO` level. */
+    info(strings: TemplateStringsArray, ...data: unknown[]): void;
+    /** Log a message with `WARN` level. */
+    warn(strings: TemplateStringsArray, ...data: unknown[]): void;
+    /** Log a message with `ERROR` level. */
+    error(strings: TemplateStringsArray, ...data: unknown[]): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/packages/core/logger/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../../../packages/core/logger/logger.ts"],"names":[],"mappings":"AACA,OAAO,EAAa,KAAK,EAAE,KAAK,OAAO,EAAsB,MAAM,cAAc,CAAC;AAClF,OAAO,KAAK,EAAa,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAalE;;GAEG;AACH,qBAAa,MAAM;IAqDf,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM;IArDzB;;;;;;;;OAQG;IACH,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;IAMjD;;;;;;;;OAQG;IACH,MAAM,CAAC,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,eAAe,GAAE,gBAA0C;IAc5G;;;;;OAKG;IACH,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,MAAM;IAK3E,OAAO,CAAC,kBAAkB,CAAC,CAA2B;IAEtD,OAAO;IAKP,0DAA0D;IAC1D,QAAQ,IAAI,KAAK;IAIjB,OAAO,CAAC,eAAe;IAUvB,yCAAyC;IACzC,MAAM,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE;IAIxD,wCAAwC;IACxC,KAAK,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE;IAIvD,8CAA8C;IAC9C,GAAG,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE;IAIrD,uCAAuC;IACvC,IAAI,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE;IAItD,uCAAuC;IACvC,IAAI,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE;IAItD,wCAAwC;IACxC,KAAK,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE;CAGxD"}

package/packages/core/logger/logger.js

@@ -0,0 +1,104 @@
+import { ConsoleTransport } from "./console.js";
+import { findLevel, Level, parseLoggerOptions } from "./options.js";
+const DEFAULT_OPTIONS = {
+    workingDir: "",
+    defaultLevel: Level.LOG,
+    modules: new Map(),
+};
+const GLOBAL_CONFIG = {
+    options: DEFAULT_OPTIONS,
+    transport: ConsoleTransport.create(DEFAULT_OPTIONS.defaultLevel, DEFAULT_OPTIONS),
+};
+/**
+ * A logger instance.
+ */
+export class Logger {
+    moduleName;
+    config;
+    /**
+     * Create a new logger instance given filename and an optional module name.
+     *
+     * If the module name is not given, `fileName` becomes the module name.
+     * The module name can be composed from multiple parts separated with `/`.
+     *
+     * The logger will use a global configuration which can be changed using
+     * [`configureLogger`] function.
+     */
+    static new(fileName, moduleName) {
+        const fName = fileName ?? "unknown";
+        const module = moduleName ?? fName;
+        return new Logger(module, GLOBAL_CONFIG);
+    }
+    /**
+     * Global configuration of all loggers.
+     *
+     * One can specify a default logging level (only logs with level >= default will be printed).
+     * It's also possible to configure per-module logging level that takes precedence
+     * over the default one.
+     *
+     * Changing the options affects all previously created loggers.
+     */
+    static configureAllFromOptions(options, createTransport = ConsoleTransport.create) {
+        // find minimal level to optimise logging in case
+        // we don't care about low-level logs.
+        const minimalLevel = Array.from(options.modules.values()).reduce((level, modLevel) => {
+            return level < modLevel ? level : modLevel;
+        }, options.defaultLevel);
+        const transport = createTransport(minimalLevel, options);
+        // set the global config
+        GLOBAL_CONFIG.options = options;
+        GLOBAL_CONFIG.transport = transport;
+    }
+    /**
+     * Global configuration of all loggers.
+     *
+     * Parse configuration options from an input string typically obtained
+     * from environment variable `JAM_LOG`.
+     */
+    static configureAll(input, defaultLevel, workingDir) {
+        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 moduleName = this.moduleName;
+            const level = findLevel(this.config.options, moduleName);
+            const shortName = 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);
+    }
+    /** Log a message with `TRACE` level. */
+    trace(strings, ...data) {
+        this.config.transport.trace(this.getLevelAndName(), strings, data);
+    }
+    /** Log a message with `DEBUG`/`LOG` level. */
+    log(strings, ...data) {
+        this.config.transport.log(this.getLevelAndName(), strings, data);
+    }
+    /** Log a message with `INFO` level. */
+    info(strings, ...data) {
+        this.config.transport.info(this.getLevelAndName(), strings, data);
+    }
+    /** Log a message with `WARN` level. */
+    warn(strings, ...data) {
+        this.config.transport.warn(this.getLevelAndName(), strings, data);
+    }
+    /** Log a message with `ERROR` level. */
+    error(strings, ...data) {
+        this.config.transport.error(this.getLevelAndName(), strings, data);
+    }
+}

package/packages/core/logger/logger.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logger.test.d.ts.map

package/packages/core/logger/logger.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.test.d.ts","sourceRoot":"","sources":["../../../../../packages/core/logger/logger.test.ts"],"names":[],"mappings":""}

package/packages/core/logger/logger.test.js

@@ -0,0 +1,104 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { Logger } from "./logger.js";
+import { Level } from "./options.js";
+describe("Logger", () => {
+    it("should call transport methods with correct log levels", () => {
+        const mockTransport = new MockTransport();
+        // Configure logger with mock transport
+        Logger.configureAllFromOptions({
+            workingDir: "",
+            defaultLevel: Level.INSANE,
+            modules: new Map(),
+        }, () => mockTransport);
+        const logger = Logger.new("test");
+        // Test all log levels
+        logger.insane `insane message`;
+        logger.trace `trace message`;
+        logger.log `log message`;
+        logger.info `info message`;
+        logger.warn `warn message`;
+        logger.error `error message`;
+        assert.strictEqual(mockTransport.calls.length, 6);
+        assert.strictEqual(mockTransport.calls[0].level, Level.INSANE);
+        assert.strictEqual(mockTransport.calls[1].level, Level.TRACE);
+        assert.strictEqual(mockTransport.calls[2].level, Level.LOG);
+        assert.strictEqual(mockTransport.calls[3].level, Level.INFO);
+        assert.strictEqual(mockTransport.calls[4].level, Level.WARN);
+        assert.strictEqual(mockTransport.calls[5].level, Level.ERROR);
+        assert.strictEqual(mockTransport.calls[0].levelAndName[1], "test");
+    });
+    it("should return the configured log level", () => {
+        Logger.configureAllFromOptions({
+            workingDir: "",
+            defaultLevel: Level.INFO,
+            modules: new Map(),
+        }, () => ({
+            insane: () => { },
+            trace: () => { },
+            log: () => { },
+            info: () => { },
+            warn: () => { },
+            error: () => { },
+        }));
+        const logger = Logger.new("test");
+        assert.strictEqual(logger.getLevel(), Level.INFO);
+    });
+    it("should respect module-specific log levels", () => {
+        const mockTransport = new MockTransport();
+        // Configure with TRACE as default, but pvm module with INSANE level
+        Logger.configureAllFromOptions({
+            workingDir: "",
+            defaultLevel: Level.TRACE,
+            modules: new Map([["pvm", Level.INSANE]]),
+        }, () => mockTransport);
+        const pvmLogger = Logger.new("pvm");
+        const otherLogger = Logger.new("other");
+        // pvm logger should output INSANE messages
+        pvmLogger.insane `pvm insane message`;
+        pvmLogger.trace `pvm trace message`;
+        // other logger should NOT output INSANE messages (default is TRACE)
+        otherLogger.insane `other insane message`;
+        otherLogger.trace `other trace message`;
+        // Verify pvm logger outputs both insane and trace
+        const pvmCalls = mockTransport.calls.filter((c) => c.levelAndName[1] === "pvm");
+        assert.strictEqual(pvmCalls.length, 2);
+        assert.strictEqual(pvmCalls[0].level, Level.INSANE);
+        assert.strictEqual(pvmCalls[0].message, "pvm insane message");
+        assert.strictEqual(pvmCalls[1].level, Level.TRACE);
+        assert.strictEqual(pvmCalls[1].message, "pvm trace message");
+        // Verify other logger only outputs trace (not insane)
+        const otherCalls = mockTransport.calls.filter((c) => c.levelAndName[1] === "other");
+        assert.strictEqual(otherCalls.length, 1);
+        assert.strictEqual(otherCalls[0].level, Level.TRACE);
+        assert.strictEqual(otherCalls[0].message, "other trace message");
+    });
+});
+/** Mock transport that stores all log calls for testing purposes. */
+class MockTransport {
+    calls = [];
+    appendCall(level, levelAndName, strings) {
+        if (level < levelAndName[0]) {
+            return;
+        }
+        this.calls.push({ level, levelAndName, message: String(strings[0]) });
+    }
+    insane(levelAndName, strings) {
+        this.appendCall(Level.INSANE, levelAndName, strings);
+    }
+    trace(levelAndName, strings) {
+        this.appendCall(Level.TRACE, levelAndName, strings);
+    }
+    log(levelAndName, strings) {
+        this.appendCall(Level.LOG, levelAndName, strings);
+    }
+    info(levelAndName, strings) {
+        this.appendCall(Level.INFO, levelAndName, strings);
+    }
+    warn(levelAndName, strings) {
+        this.appendCall(Level.WARN, levelAndName, strings);
+    }
+    error(levelAndName, strings) {
+        this.appendCall(Level.ERROR, levelAndName, strings);
+    }
+}

package/packages/core/logger/options.d.ts

@@ -0,0 +1,37 @@
+export declare enum Level {
+    INSANE = 1,
+    TRACE = 2,
+    LOG = 3,
+    INFO = 4,
+    WARN = 5,
+    ERROR = 6
+}
+export type Options = {
+    defaultLevel: Level;
+    workingDir: string;
+    modules: Map<string, Level>;
+};
+/**
+ * Find a configured log level for given module.
+ *
+ * The function will attempt to find the most detailed level for given module
+ * by checking if logging is configured for it's parent modules if it's not for
+ * the specific name.
+ *
+ * E.g. `consensus/voting`
+ *
+ * We can have no level configured for `consensus/voting`, but if there is a `WARN`
+ * level for `consensus`, this function would return `Level.WARN` even though
+ * the default log level might be `Level.LOG`.
+ */
+export declare function findLevel(options: Options, moduleName: string): Level;
+/**
+ * A function to parse logger definition (including modules) given as a string.
+ *
+ * Examples
+ *  - `info` - setup default logging level to `info`.
+ *  - `trace` - default logging level set to `trace`.
+ *  - `debug;consensus=trace` - default level is set to `debug/log`, but consensus is in trace mode.
+ */
+export declare function parseLoggerOptions(input: string, defaultLevel: Level, workingDir?: string): Options;
+//# sourceMappingURL=options.d.ts.map

package/packages/core/logger/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../../../packages/core/logger/options.ts"],"names":[],"mappings":"AAAA,oBAAY,KAAK;IACf,MAAM,IAAI;IACV,KAAK,IAAI;IACT,GAAG,IAAI;IACP,IAAI,IAAI;IACR,IAAI,IAAI;IACR,KAAK,IAAI;CACV;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,YAAY,EAAE,KAAK,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,KAAK,CAerE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CA6BnG"}

package/packages/core/logger/options.js

@@ -0,0 +1,80 @@
+export var Level;
+(function (Level) {
+    Level[Level["INSANE"] = 1] = "INSANE";
+    Level[Level["TRACE"] = 2] = "TRACE";
+    Level[Level["LOG"] = 3] = "LOG";
+    Level[Level["INFO"] = 4] = "INFO";
+    Level[Level["WARN"] = 5] = "WARN";
+    Level[Level["ERROR"] = 6] = "ERROR";
+})(Level || (Level = {}));
+/**
+ * Find a configured log level for given module.
+ *
+ * The function will attempt to find the most detailed level for given module
+ * by checking if logging is configured for it's parent modules if it's not for
+ * the specific name.
+ *
+ * E.g. `consensus/voting`
+ *
+ * We can have no level configured for `consensus/voting`, but if there is a `WARN`
+ * level for `consensus`, this function would return `Level.WARN` even though
+ * the default log level might be `Level.LOG`.
+ */
+export function findLevel(options, moduleName) {
+    let parentModuleName = moduleName;
+    for (;;) {
+        const level = options.modules.get(parentModuleName);
+        if (level !== undefined) {
+            return level;
+        }
+        const lastSlash = parentModuleName.lastIndexOf("/");
+        if (lastSlash === -1) {
+            return options.defaultLevel;
+        }
+        parentModuleName = moduleName.substring(0, lastSlash);
+    }
+}
+/**
+ * A function to parse logger definition (including modules) given as a string.
+ *
+ * Examples
+ *  - `info` - setup default logging level to `info`.
+ *  - `trace` - default logging level set to `trace`.
+ *  - `debug;consensus=trace` - default level is set to `debug/log`, but consensus is in trace mode.
+ */
+export function parseLoggerOptions(input, defaultLevel, workingDir) {
+    const modules = new Map();
+    const parts = input.toLowerCase().split(",");
+    let defLevel = defaultLevel;
+    for (const p of parts) {
+        const clean = p.trim();
+        // skip empty objects (forgotten `,` removed)
+        if (clean.length === 0) {
+            continue;
+        }
+        // we just have the default level
+        if (clean.includes("=")) {
+            const [mod, lvl] = clean.split("=");
+            modules.set(mod.trim(), parseLevel(lvl.trim()));
+        }
+        else {
+            defLevel = parseLevel(clean);
+        }
+    }
+    // TODO [ToDr] Fix dirname for workers.
+    const myDir = (import.meta.dirname ?? "").split("/");
+    myDir.pop();
+    myDir.pop();
+    return {
+        defaultLevel: defLevel,
+        modules,
+        workingDir: workingDir ?? myDir.join("/"),
+    };
+}
+function parseLevel(lvl) {
+    const typedLvl = lvl === "debug" ? "LOG" : lvl.toUpperCase();
+    if (Level[typedLvl] === undefined) {
+        throw new Error(`Unknown logging level: "${lvl}". Use one of "trace", "debug", "log","info", "warn", "error" or "insane"`);
+    }
+    return Level[typedLvl];
+}

package/packages/core/logger/options.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=options.test.d.ts.map

package/packages/core/logger/options.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.test.d.ts","sourceRoot":"","sources":["../../../../../packages/core/logger/options.test.ts"],"names":[],"mappings":""}

package/packages/core/logger/options.test.js

@@ -0,0 +1,92 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { findLevel, Level, parseLoggerOptions } from "./options.js";
+describe("Options.findLevel", () => {
+    it("should return default level when nothing is present", () => {
+        const expectedLevel = findLevel({
+            defaultLevel: Level.TRACE,
+            workingDir: ".",
+            modules: new Map(),
+        }, "consensus/voting");
+        assert.strictEqual(expectedLevel, Level.TRACE);
+    });
+    it("should return specialized level", () => {
+        const modules = new Map();
+        modules.set("consensus/voting", Level.WARN);
+        const expectedLevel = findLevel({
+            defaultLevel: Level.TRACE,
+            workingDir: ".",
+            modules,
+        }, "consensus/voting");
+        assert.strictEqual(expectedLevel, Level.WARN);
+    });
+    it("should return specialized level when parent is defined", () => {
+        const modules = new Map();
+        modules.set("consensus", Level.ERROR);
+        const expectedLevel = findLevel({
+            defaultLevel: Level.TRACE,
+            workingDir: ".",
+            modules,
+        }, "consensus/voting");
+        assert.strictEqual(expectedLevel, Level.ERROR);
+    });
+});
+describe("Options.parseLoggerOptions", () => {
+    it("parse default level and disregard case and whitespace", () => {
+        const modules = new Map();
+        const expectedOptions = {
+            defaultLevel: Level.INFO,
+            workingDir: ".",
+            modules,
+        };
+        // when
+        const parsedOptions = parseLoggerOptions("InFO ", Level.LOG);
+        expectedOptions.workingDir = parsedOptions.workingDir;
+        // then
+        assert.deepStrictEqual(expectedOptions, parsedOptions);
+    });
+    it("should return specialized level when parent is defined", () => {
+        const modules = new Map();
+        modules.set("consensus", Level.ERROR);
+        const expectedOptions = {
+            defaultLevel: Level.TRACE,
+            workingDir: ".",
+            modules,
+        };
+        // when
+        const parsedOptions = parseLoggerOptions("trace,consensus=error", Level.WARN);
+        expectedOptions.workingDir = parsedOptions.workingDir;
+        // then
+        assert.deepStrictEqual(expectedOptions, parsedOptions);
+    });
+    it("should parse more complicated case", () => {
+        const modules = new Map();
+        modules.set("consensus", Level.ERROR);
+        modules.set("consensus/voting", Level.TRACE);
+        const expectedOptions = {
+            defaultLevel: Level.LOG,
+            workingDir: ".",
+            modules,
+        };
+        // when
+        const parsedOptions = parseLoggerOptions("consensus=error , consensus/voting = TRACE, debug", Level.WARN);
+        expectedOptions.workingDir = parsedOptions.workingDir;
+        // then
+        assert.deepStrictEqual(expectedOptions, parsedOptions);
+    });
+    it("should use a default logging level", () => {
+        const modules = new Map();
+        modules.set("consensus", Level.ERROR);
+        modules.set("consensus/voting", Level.TRACE);
+        const expectedOptions = {
+            defaultLevel: Level.LOG,
+            workingDir: ".",
+            modules,
+        };
+        // when
+        const parsedOptions = parseLoggerOptions("consensus=error , consensus/voting = TRACE,", Level.LOG);
+        expectedOptions.workingDir = parsedOptions.workingDir;
+        // then
+        assert.deepStrictEqual(expectedOptions, parsedOptions);
+    });
+});

package/packages/core/logger/transport.d.ts

@@ -0,0 +1,20 @@
+import type { Level, Options } from "./options.js";
+export type TransportBuilder = (minLevel: Level, options: Options) => Transport;
+/**
+ * An interface for the logger `Transport`.
+ */
+export interface Transport {
+    /** INSANE message */
+    insane(levelAndName: readonly [Level, string], _strings: TemplateStringsArray, _data: unknown[]): void;
+    /** TRACE message */
+    trace(levelAndName: readonly [Level, string], strings: TemplateStringsArray, data: unknown[]): void;
+    /** DEBUG/LOG message */
+    log(levelAndName: readonly [Level, string], strings: TemplateStringsArray, data: unknown[]): void;
+    /** INFO message */
+    info(levelAndName: readonly [Level, string], strings: TemplateStringsArray, data: unknown[]): void;
+    /** WARN message */
+    warn(levelAndName: readonly [Level, string], strings: TemplateStringsArray, data: unknown[]): void;
+    /** ERROR message */
+    error(levelAndName: readonly [Level, string], strings: TemplateStringsArray, data: unknown[]): void;
+}
+//# sourceMappingURL=transport.d.ts.map

package/packages/core/logger/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../../../../packages/core/logger/transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEnD,MAAM,MAAM,gBAAgB,GAAG,CAAC,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,KAAK,SAAS,CAAC;AAChF;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,qBAAqB;IACrB,MAAM,CAAC,YAAY,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,oBAAoB,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IACvG,oBAAoB;IACpB,KAAK,CAAC,YAAY,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,oBAAoB,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IACpG,wBAAwB;IACxB,GAAG,CAAC,YAAY,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,oBAAoB,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAClG,mBAAmB;IACnB,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,oBAAoB,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IACnG,mBAAmB;IACnB,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,oBAAoB,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IACnG,oBAAoB;IACpB,KAAK,CAAC,YAAY,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,oBAAoB,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;CACrG"}

package/packages/core/logger/transport.js

@@ -0,0 +1 @@
+export {};

package/packages/core/mmr/index.d.ts

@@ -0,0 +1,48 @@
+import { BytesBlob } from "#@typeberry/bytes";
+import { type OpaqueHash } from "#@typeberry/hash";
+/** Merkle Mountain Range peaks. */
+export interface MmrPeaks<H extends OpaqueHash> {
+    /**
+     * Peaks at particular positions.
+     *
+     * In case there is no merkle trie at given index, `null` is placed.
+     */
+    peaks: readonly (H | null)[];
+}
+/** Hasher interface for MMR. */
+export interface MmrHasher<H extends OpaqueHash> {
+    /** Hash two items together. */
+    hashConcat(a: H, b: H): H;
+    /** Hash two items together with extra bytes blob prepended. */
+    hashConcatPrepend(id: BytesBlob, a: H, b: H): H;
+}
+/**
+ * Merkle Mountain Range.
+ *
+ * https://graypaper.fluffylabs.dev/#/5f542d7/3aa0023aa002?v=0.6.2
+ */
+export declare class MerkleMountainRange<H extends OpaqueHash> {
+    private readonly hasher;
+    /** Store non-empty merkle tries (mountains) ordered by descending size. */
+    private readonly mountains;
+    /** Construct an empty MMR. */
+    static empty<H extends OpaqueHash>(hasher: MmrHasher<H>): MerkleMountainRange<H>;
+    /** Construct a new MMR from existing peaks. */
+    static fromPeaks<H extends OpaqueHash>(hasher: MmrHasher<H>, mmr: MmrPeaks<H>): MerkleMountainRange<H>;
+    private constructor();
+    /**
+     * Append a new hash to the MMR structure.
+     *
+     * https://graypaper.fluffylabs.dev/#/5f542d7/3b11003b1100?v=0.6.2
+     */
+    append(hash: H): void;
+    /**
+     * Root of the entire structure.
+     *
+     * https://graypaper.fluffylabs.dev/#/5f542d7/3b20013b2001?v=0.6.2
+     */
+    getSuperPeakHash(): H;
+    /** Get current peaks. */
+    getPeaks(): MmrPeaks<H>;
+}
+//# sourceMappingURL=index.d.ts.map

package/packages/core/mmr/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/core/mmr/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAa,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAI7D,mCAAmC;AACnC,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,UAAU;IAC5C;;;;OAIG;IACH,KAAK,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC;CAC9B;AAED,gCAAgC;AAChC,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,UAAU;IAC7C,+BAA+B;IAC/B,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAC1B,+DAA+D;IAC/D,iBAAiB,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;CACjD;AAED;;;;GAIG;AACH,qBAAa,mBAAmB,CAAC,CAAC,SAAS,UAAU;IAsBjD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,2EAA2E;IAC3E,OAAO,CAAC,QAAQ,CAAC,SAAS;IAvB5B,8BAA8B;IAC9B,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,UAAU,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IAIvD,+CAA+C;IAC/C,MAAM,CAAC,SAAS,CAAC,CAAC,SAAS,UAAU,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC;IAc7E,OAAO;IAMP;;;;OAIG;IACH,MAAM,CAAC,IAAI,EAAE,CAAC;IAoBd;;;;OAIG;IACH,gBAAgB,IAAI,CAAC;IAcrB,yBAAyB;IACzB,QAAQ,IAAI,QAAQ,CAAC,CAAC,CAAC;CAoBxB"}